ACE_CDR::Boolean
UTF16_UCS2_Translator::read_wstring (ACE_InputCDR &cdr,
ACE_CDR::WChar *&x)
{
ACE_CDR::ULong len;
if (!this->read_4 (cdr, &len))
return 0;
// A check for the length being too great is done later in the
// call to read_char_array but we want to have it done before
// the memory is allocated.
if (len > 0 && len <= cdr.length())
{
if (static_cast <ACE_CDR::Short> (this->major_version(cdr)) == 1
&& static_cast <ACE_CDR::Short> (this->minor_version(cdr)) == 2)
{
len /= ACE_UTF16_CODEPOINT_SIZE;
//allocating one extra for the null character needed by applications
ACE_NEW_RETURN (x,
ACE_CDR::WChar [len + 1],
0);
x[len] = L'\x00';
if (this->read_wchar_array_i (cdr, x, len, 1))
{
// Since reading the array may have adjusted the length,
// we simply rewrite the null terminator
x[len] = L'\x00';
return 1;
}
}
else
{
ACE_NEW_RETURN (x,
ACE_CDR::WChar [len],
0);
if (this->read_wchar_array (cdr, x, len))
return 1;
}
delete [] x;
}
else if (len == 0)
{
// Convert any null strings to empty strings since empty
// strings can cause crashes. (See bug 58.)
ACE_NEW_RETURN (x,
ACE_CDR::WChar[1],
0);
x[0] = '\x00';
return 1;
}
x = 0;
return 0;
}
virtual int svc () {
const size_t FileReadSize = 8 * 1024;
ACE_Message_Block mblk (FileReadSize);
for (;; mblk.crunch ()) {
// Read as much as will fit in the message block.
ssize_t bytes_read = logfile_.recv (mblk.wr_ptr (),
mblk.space ());
if (bytes_read <= 0)
break;
mblk.wr_ptr (static_cast<size_t> (bytes_read));
// We have a bunch of data from the log file. The data is
// arranged like so:
// hostname\0
// CDR-encoded log record
// So, first we scan for the end of the host name, then
// initialize another ACE_Message_Block aligned for CDR
// demarshaling and copy the remainder of the block into it. We
// can't use duplicate() because we need to be sure the data
// pointer is aligned properly for CDR demarshaling. If at any
// point, there's not enough data left in the message block to
// extract what's needed, crunch the block to move all remaining
// data to the beginning and read more from the file.
for (;;) {
size_t name_len = ACE_OS::strnlen
(mblk.rd_ptr (), mblk.length ());
if (name_len == mblk.length ()) break;
char *name_p = mblk.rd_ptr ();
ACE_Message_Block *rec, *head, *temp;
ACE_NEW_RETURN
(head, ACE_Message_Block (name_len, MB_CLIENT), 0);
head->copy (name_p, name_len);
mblk.rd_ptr (name_len + 1); // Skip nul also
size_t need = mblk.length () + ACE_CDR::MAX_ALIGNMENT;
ACE_NEW_RETURN (rec, ACE_Message_Block (need), 0);
ACE_CDR::mb_align (rec);
rec->copy (mblk.rd_ptr (), mblk.length ());
// Now rec contains the remaining data we've read so far from
// the file. Create an ACE_InputCDR to start demarshaling the
// log record, header first to find the length, then the data.
// Since the ACE_InputCDR constructor increases the reference count
// on rec, we release it upon return to prevent leaks.
// The cdr 'read' methods return 0 on failure, 1 on success.
ACE_InputCDR cdr (rec); rec->release ();
ACE_CDR::Boolean byte_order;
if (!cdr.read_boolean (byte_order)) {
head->release (); rec->release (); break;
}
cdr.reset_byte_order (byte_order);
// Now read the length of the record. From there, we'll know
// if rec contains the complete record or not.
ACE_CDR::ULong length;
if (!cdr.read_ulong (length)) {
head->release (); mblk.rd_ptr (name_p); break;
}
if (length > cdr.length ()) {
head->release (); mblk.rd_ptr (name_p); break;
}
// The complete record is in rec... grab all the fields into
// separate, chained message blocks.
ACE_NEW_RETURN (temp,
ACE_Message_Block (length, MB_TEXT),
0);
ACE_NEW_RETURN
(temp,
ACE_Message_Block (2 * sizeof (ACE_CDR::Long),
MB_TIME, temp),
0);
ACE_NEW_RETURN
(temp,
ACE_Message_Block (sizeof (ACE_CDR::Long),
MB_PID, temp),
0);
ACE_NEW_RETURN
(temp,
ACE_Message_Block (sizeof (ACE_CDR::Long),
MB_TYPE, temp),
0);
head->cont (temp);
// Extract the type
ACE_CDR::Long *lp;
lp = reinterpret_cast<ACE_CDR::Long*> (temp->wr_ptr ());
cdr >> *lp;
temp->wr_ptr (sizeof (ACE_CDR::Long));
temp = temp->cont ();
// Extract the pid
lp = reinterpret_cast<ACE_CDR::Long*> (temp->wr_ptr ());
cdr >> *lp;
temp->wr_ptr (sizeof (ACE_CDR::Long));
temp = temp->cont ();
// Extract the timestamp (2 Longs)
lp = reinterpret_cast<ACE_CDR::Long*> (temp->wr_ptr ());
cdr >> *lp; ++lp; cdr >> *lp;
temp->wr_ptr (2 * sizeof (ACE_CDR::Long));
temp = temp->cont ();
// Demarshal the length of the message text, then demarshal
// the text into the block.
ACE_CDR::ULong text_len;
cdr >> text_len;
cdr.read_char_array (temp->wr_ptr (), text_len);
temp->wr_ptr (text_len);
// Forward the whole lot to the next module.
if (put_next (head) == -1) break;
// Move the file-content block's read pointer up past whatever
// was just processed. Although the mblk's rd_ptr has not been
// moved, cdr's has. Therefore, use its length() to determine
// how much is left.
mblk.rd_ptr (mblk.length () - cdr.length ());
}
}
// Now that the file is done, send a block down the stream to tell
// the other modules to stop.
ACE_Message_Block *stop;
ACE_NEW_RETURN
(stop, ACE_Message_Block (0, ACE_Message_Block::MB_STOP),
0);
put_next (stop);
return 0;
}
