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);
}
int main(int argc, char** argv)
{
const char* pathname = argc > 1 ? argv[1] : "/index.html";
const char* server_hostname = argc > 2 ? argv[2] : "ace.ece.uci.edu";
// Add funcation call for demo.
dummy();
ACE_SOCK_Connector connector;
ACE_SOCK_Stream peer;
ACE_INET_Addr peer_addr;
if (-1 == peer_addr.set(80, server_hostname))
{
log("peer_addr.set failed\n");
return 1;
}
else if (-1 == connector.connect(peer, peer_addr))
{
log("connector.connect failed\n");
return 1;
}
char buf[BUFSIZ];
iovec iov[3];
iov[0].iov_base = (void*)"GET ";
iov[0].iov_len = 4;
iov[1].iov_base = (void*)pathname;
iov[1].iov_len = strlen(pathname);
iov[2].iov_base = (void*)" HTTP/1.0\r\n\r\n";
iov[2].iov_len = 13;
if (-1 == peer.sendv_n(iov, 3))
{
log("peer.sendv_v failed\n");
return 1;
}
for (ssize_t n = 0; (n = peer.recv(buf, sizeof(buf))) > 0; )
{
ACE::write_n(ACE_STDOUT, buf, n);
}
return peer.close();
}
//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);
}
// conduct the UnMarshalled Octet performance test using separate
// send_n calls with Nagle's algorithm disabled
ACE_SCTP::HIST runUnmarshalledOctetTest(ACE_CDR::Octet *buf, size_t seqLen, ACE_SOCK_Stream & stream){
ACE_CDR::ULong const testIterations = Options_Manager::test_iterations;
size_t bt;
ACE_CDR::ULong cnt = 0;
// variables for the timing measurements
ACE_hrtime_t startTime, endTime;
ACE_CDR::Double messageLatency_usec = 0.0;
ACE_CDR::ULong msgLen = seqLen*ACE_CDR::OCTET_SIZE;
// explicity configure Nagling. Default is
// Options_Manager::test_enable_nagle=0 so default configurations is
// NO NAGLING
ACE_CDR::Long nagle;
if (Options_Manager::test_enable_nagle)
nagle=0;
else
nagle=1;
if (Options_Manager::test_transport_protocol == IPPROTO_SCTP){
// default - sctp case
if (-1 == stream.set_option(IPPROTO_SCTP, SCTP_NODELAY, &nagle, sizeof nagle))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"set_option"),
0);
} else {
// tcp case
if (-1 == stream.set_option(IPPROTO_TCP, TCP_NODELAY, &nagle, sizeof nagle))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"set_option"),
0);
}
// prime the client and server before starting the test
for(cnt=0;cnt<primerIterations;++cnt){
// send message size
// TODO : The message length should be CDR encoded
ACE_CDR::ULong msgLenExpressed = ACE_HTONL(msgLen);
if (-1 == stream.send_n (&msgLenExpressed, ACE_CDR::LONG_SIZE, 0, &bt))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"send_n"),
0);
// send a message
if (-1 == stream.send_n (buf, msgLen, 0, &bt))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"send_n"),
0);
// block for a Short reply
ACE_CDR::Short reply;
if ((stream.recv_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"recv_n"),
0);
}
// AFTER PRIMING THE PUMP CREATE THE HISTOGRAM
ACE_SCTP::HIST aceStream_hist = 0;
aceStream_hist = createHistogram(msgLen);
if (0 == aceStream_hist)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"histogram create failed"),
0);
iovec iov[2];
// PERFORMANCE TEST LOOP
for (cnt = 0; cnt < testIterations; ++cnt){
// get the start time
startTime = ACE_OS::gethrtime();
if (!startTime)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"ACE_OS::gethrtime()"),
0);
ACE_CDR::ULong msgLenExpressed = ACE_HTONL(msgLen);
iov[0].iov_base = reinterpret_cast<char *> (&msgLenExpressed);
iov[0].iov_len = ACE_CDR::LONG_SIZE;
iov[1].iov_base = reinterpret_cast<char *> (buf);
iov[1].iov_len = msgLen;
if (-1 == stream.sendv_n (iov, 2))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"send_n"),
0);
// block for a Short reply
ACE_CDR::Short reply;
if ((stream.recv_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"recv_n"),
0);
// get the end time
endTime = ACE_OS::gethrtime();
if (!endTime)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"ACE_OS::gethrtime()"),
0);
// compute the message latency in micro-seconds
messageLatency_usec =
(static_cast<double> (ACE_UINT64_DBLCAST_ADAPTER(endTime)) -
static_cast<double> (ACE_UINT64_DBLCAST_ADAPTER(startTime)))
/ microsec_clock_scale_factor;
// record the message latency in the histogram
ACE_SCTP::record(messageLatency_usec, aceStream_hist);
}
// THE HEADER MESSAGE SENT TO THE SERVER CONTAINED THE NUMBER OF
// PRIMER AND TEST MESSAGES TO BE SENT AFTER WHICH THE SERVER WILL
// CLOSE THE STREAM SO ONCE WE REACH THIS POINT THE STREAM IS NO
// LONGER VALID AND WE CLOSE IT.
stream.close();
// allocated by runTest
delete[] buf;
return aceStream_hist;
}
int
InfoRepoMulticastResponder::handle_input(ACE_HANDLE)
{
if (OpenDDS::DCPS::DCPS_debug_level > 0)
ACE_DEBUG((LM_DEBUG, "Entered InfoRepoMulticastResponder::handle_input\n"));
// The length of the service name string that follows.
CORBA::Short header;
// Port to which to reply.
ACE_UINT16 remote_port;
// Name of the service for which the client is looking.
char object_key[BUFSIZ];
ACE_INET_Addr remote_addr;
// Take a peek at the header to find out how long is the service
// name string we should receive.
ssize_t n = this->mcast_dgram_.recv(&header,
sizeof(header),
remote_addr,
MSG_PEEK);
if (n <= 0)
ACE_ERROR_RETURN((LM_ERROR,
"InfoRepoMulticastResponder::handle_input - peek %d\n",
n),
0);
else if (ACE_NTOHS(header) <= 0)
ACE_ERROR_RETURN((LM_ERROR,
"InfoRepoMulticastResponder::handle_input() Header value < 1\n"),
0);
// Receive full client multicast request.
const int iovcnt = 3;
iovec iov[iovcnt];
iov[0].iov_base = (char *) &header;
iov[0].iov_len = sizeof(header);
iov[1].iov_base = (char *) &remote_port;
iov[1].iov_len = sizeof(ACE_UINT16);
iov[2].iov_base = (char *) object_key;
iov[2].iov_len = ACE_NTOHS(header);
// Read the iovec.
n = this->mcast_dgram_.recv(iov,
iovcnt,
remote_addr);
if (n <= 0)
ACE_ERROR_RETURN((LM_ERROR,
"InfoRepoMulticastResponder::handle_input recv = %d\n",
n),
0);
if (OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_TCHAR addr[64];
remote_addr.addr_to_string(addr, sizeof(addr));
ACE_DEBUG((LM_DEBUG,
"(%P|%t) Received multicast from %s.\n"
"Service Name received : %C\n"
"Port received : %u\n",
addr,
object_key,
ACE_NTOHS(remote_port)));
}
// Grab the IOR table.
CORBA::Object_var table_object =
orb_->resolve_initial_references("IORTable");
IORTable::Locator_var locator =
IORTable::Locator::_narrow(table_object.in());
if (CORBA::is_nil(locator.in())) {
ACE_ERROR((LM_ERROR, ACE_TEXT("Nil IORTable\n")));
}
std::string ior;
{
CORBA::String_var ior_result;
try {
ior_result = locator->locate(object_key);
} catch (const IORTable::NotFound&) {
ACE_ERROR_RETURN((LM_ERROR,
"InfoRepoMulticastResponder::handle_input() Object key not found\n"),
0);
}
ior = ior_result;
}
// Reply to the multicast message.
ACE_SOCK_Connector connector;
ACE_INET_Addr peer_addr;
ACE_SOCK_Stream stream;
peer_addr.set(remote_addr);
peer_addr.set_port_number(ACE_NTOHS(remote_port));
#if defined (ACE_HAS_IPV6)
if (peer_addr.is_linklocal()) {
// If this is one of our local linklocal interfaces this is not going
// to work.
// Creating a connection using such interface to the client listening
// at the IPv6 ANY address is not going to work (I'm not quite sure why
// but it probably has to do with the rather restrictive routing rules
// for linklocal interfaces).
// So we see if this is one of our local interfaces and if so create the
// connection using the IPv6 loopback address instead.
ACE_INET_Addr peer_tmp(peer_addr);
peer_tmp.set_port_number(static_cast<u_short>(0));
ACE_INET_Addr* tmp = 0;
size_t cnt = 0;
int err = ACE::get_ip_interfaces(cnt, tmp);
if (err == 0) {
for (size_t i = 0; i < cnt; ++i) {
if (peer_tmp == tmp[i]) {
peer_addr.set(ACE_NTOHS(remote_port),
ACE_IPV6_LOCALHOST);
break;
}
}
delete[] tmp;
}
}
#endif /* ACE_HAS_IPV6 */
if (OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_TCHAR addr[64];
peer_addr.addr_to_string(addr, sizeof(addr));
ACE_DEBUG((LM_DEBUG,
"(%P|%t) Replying to peer %s.\n",
addr));
}
// Connect.
if (connector.connect(stream, peer_addr) == -1)
ACE_ERROR_RETURN((LM_ERROR, "InfoRepoMulticastResponder::connect failed\n"), 0);
// Send the IOR back to the client. (Send iovec, which contains ior
// length as the first element, and ior itself as the second.)
// Length of ior to be sent.
CORBA::Short data_len =
static_cast<CORBA::Short>(ACE_HTONS(ior.length() + 1));
// Vector to be sent.
const int cnt = 2;
iovec iovp[cnt];
// The length of ior to be sent.
iovp[0].iov_base = (char *) &data_len;
iovp[0].iov_len = sizeof(CORBA::Short);
// The ior.
iovp[1].iov_base = const_cast<char*>(ior.c_str());
iovp[1].iov_len = static_cast<u_long>(ior.length() + 1);
ssize_t result = stream.sendv_n(iovp, cnt);
// Close the stream.
stream.close();
// Check for error.
if (result == -1)
ACE_ERROR_RETURN((LM_ERROR, "InfoRepoMulticastResponder::send failed\n"), 0);
if (OpenDDS::DCPS::DCPS_debug_level > 0)
ACE_DEBUG((LM_DEBUG,
"(%P|%t) InfoRepoMulticastResponder::handle_input() ior: <%C>\n"
"sent to %C:%u.\n"
"result from send = %d\n",
ior.c_str(),
peer_addr.get_host_name(),
peer_addr.get_port_number(),
result));
return 0;
}
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;
}
bool OrkHttpClient::ExecuteUrl(const CStdString& request, CStdString& response, const CStdString& hostname, const int tcpPort, int timeout)
{
CStdString logMsg;
response = "";
ACE_SOCK_Connector connector;
ACE_SOCK_Stream peer;
ACE_INET_Addr peer_addr;
if(timeout < 1){timeout = 1;}
ACE_Time_Value aceTimeout (timeout);
CStdString requestDetails;
requestDetails.Format("timeout:%d http://%s:%d/%s", timeout, hostname, tcpPort, request);
time_t beginRequestTimestamp = time(NULL);
char szTcpPort[10];
sprintf(szTcpPort, "%d", tcpPort);
iovec iov[8];
iov[0].iov_base = (IOV_TYPE)"GET ";
iov[0].iov_len = 4; // Length of "GET ".
iov[1].iov_base = (PSTR)(PCSTR)request;
iov[1].iov_len = request.size();
iov[2].iov_base = (IOV_TYPE)" HTTP/1.0\r\n";
iov[2].iov_len = 11;
iov[3].iov_base = (IOV_TYPE)"Host: ";
iov[3].iov_len = 6;
iov[4].iov_base = (PSTR)(PCSTR)hostname;
iov[4].iov_len = hostname.size();
iov[5].iov_base = (IOV_TYPE)":";
iov[5].iov_len = 1;
iov[6].iov_base = szTcpPort;
iov[6].iov_len = strlen(szTcpPort);
iov[7].iov_base = (IOV_TYPE)"\r\n\r\n";
iov[7].iov_len = 4;
if (peer_addr.set (tcpPort, (PCSTR)hostname) == -1)
{
logMsg.Format("peer_addr.set() errno=%d %s", errno, requestDetails);
LogError(logMsg);
return false;
}
else if (connector.connect (peer, peer_addr, &aceTimeout) == -1)
{
if (errno == ETIME)
{
}
logMsg.Format("connector.connect() errno=%d %s", errno, requestDetails);
LogError(logMsg);
return false;
}
else if (peer.sendv_n (iov, 8, &aceTimeout) == -1)
{
logMsg.Format("peer.sendv_n errno=%d %s", errno, requestDetails);
LogError(logMsg);
return false;
}
ssize_t numReceived = 0;
#define BUFSIZE 4096
char buf [BUFSIZE];
CStdString header;
bool gotHeader = false;
while ( ((numReceived = peer.recv (buf, BUFSIZE, &aceTimeout)) > 0) && ((time(NULL) - beginRequestTimestamp) <= timeout) )
{
for(int i=0; i<numReceived; i++)
{
if(!gotHeader)
{
// extract header (delimited by CR-LF-CR-LF)
header += buf[i];
size_t headerSize = header.size();
if (headerSize > 4 &&
header.GetAt(headerSize-1) == '\n' &&
header.GetAt(headerSize-2) == '\r' &&
header.GetAt(headerSize-3) == '\n' &&
header.GetAt(headerSize-4) == '\r' )
{
gotHeader = true;
}
}
else
{
// extract content
response += buf[i];
}
}
}
peer.close();
logMsg.Format("%s:%d response:%s",hostname, tcpPort, response);
LOG4CXX_DEBUG(m_log, logMsg);
if(numReceived < 0)
{
logMsg.Format("numReceived:%d %s", numReceived, requestDetails);
LogError(logMsg);
return false;
}
if(header.size() > 15 && header.GetAt(9) == '4' && header.GetAt(10) == '0' && header.GetAt(11) == '0')
{
logMsg.Format("HTTP header:%s ** request:%s\nIgnore this message", header, requestDetails);
LOG4CXX_ERROR(m_log, logMsg);
return true;
}
if(header.size() < 15 || response.size() <= 0)
{
logMsg.Format("HTTP header:%s ** request:%s ** response:%s ** header size:%d response size:%d", header, requestDetails, response, header.size(), response.size());
LogError(logMsg);
return false;
}
if( header.GetAt(9) != '2' ||
header.GetAt(10) != '0' ||
header.GetAt(11) != '0' ||
header.GetAt(12) != ' ' ||
header.GetAt(13) != 'O' ||
header.GetAt(14) != 'K' )
{
logMsg.Format("HTTP header:%s ** request:%s", header, requestDetails);
LogError(logMsg);
return false;
}
return true;
}
