C++ ACE_SOCK_Stream::recv_n方法代码示例

// thread function that serves the client for the UnMarshalled Octet
// test
static ACE_THR_FUNC_RETURN unmarshalledOctetServer (void *arg){

  // unbundle the arguments
  ArgStruct * args = reinterpret_cast<ArgStruct *> (arg);
  ACE_SOCK_Stream * dataModeStream = args->stream;
  ACE_CDR::ULong numIterations = args->numIters;
  delete args;

  // serve the client for numIterations synchronous invocations
  do {

    // READ A MESSAGE FROM THE CLIENT

    size_t bt;
    ACE_CDR::ULong msgBufSize=0;
    // read the size of the buffer to follow
    if ((dataModeStream->recv_n(&msgBufSize, ACE_CDR::LONG_SIZE, 0, &bt)) == -1)
      ACE_ERROR_RETURN((LM_ERROR,
                        ACE_TEXT ("%p\n"),
                        ACE_TEXT ("recv_n")),
                       0);
    msgBufSize = ACE_NTOHL(msgBufSize);

    // allocate the buffer for the message payload
    ACE_CDR::Octet * msgBuf = 0;
    ACE_NEW_RETURN(msgBuf,
                   ACE_CDR::Octet[msgBufSize],
                   0);

    // read the buffer
    if ((dataModeStream->recv_n(msgBuf, msgBufSize, 0, &bt)) == -1)
      ACE_ERROR_RETURN((LM_ERROR,
                        ACE_TEXT ("%p\n"),
                        ACE_TEXT ("recv_n")),
                       0);

    // clean up the allocated buffer
    delete[] msgBuf;

    // SEND A REPLY TO THE CLIENT

    // send back a 2 byte reply
    ACE_CDR::Short reply;
    if ((dataModeStream->send_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
      ACE_ERROR_RETURN((LM_ERROR,
                        ACE_TEXT ("%p\n"),
                        ACE_TEXT ("send_n")),
                       0);

  } while (--numIterations);

  // close and destroy the stream
  dataModeStream->close();
  delete dataModeStream;

  return 0;
}

void
JAWS_Synch_IO::receive_file (const char *filename,
                             void *initial_data,
                             int initial_data_length,
                             int entire_length)
{
  ACE_Filecache_Handle handle (ACE_TEXT_CHAR_TO_TCHAR (filename), entire_length);

  int result = handle.error ();

  if (result == ACE_Filecache_Handle::ACE_SUCCESS)
    {
      ACE_SOCK_Stream stream;
      stream.set_handle (this->handle_);

      int bytes_to_memcpy = ACE_MIN (entire_length, initial_data_length);
      ACE_OS::memcpy (handle.address (), initial_data, bytes_to_memcpy);

      int bytes_to_read = entire_length - bytes_to_memcpy;

      int bytes = stream.recv_n ((char *) handle.address () + initial_data_length,
                                 bytes_to_read);
      if (bytes == bytes_to_read)
        this->handler_->receive_file_complete ();
      else
        result = -1;
    }

  if (result != ACE_Filecache_Handle::ACE_SUCCESS)
    this->handler_->receive_file_error (result);
}

void
JAWS_Synch_IO::receive_file (JAWS_IO_Handler *ioh,
                             const char *filename,
                             void *initial_data,
                             unsigned int initial_data_length,
                             unsigned int entire_length)
{
  ACE_Filecache_Handle handle (filename,
                               (int) entire_length);

  int result = handle.error ();

  if (result == ACE_Filecache_Handle::ACE_SUCCESS)
    {
      ACE_SOCK_Stream stream;
      stream.set_handle (ioh->handle ());

      int bytes_to_memcpy = ACE_MIN (entire_length, initial_data_length);
      ACE_OS::memcpy (handle.address (), initial_data, bytes_to_memcpy);

      int bytes_to_read = entire_length - bytes_to_memcpy;

      int bytes = stream.recv_n ((char *)
                                 handle.address () + initial_data_length,
                                 bytes_to_read);
      if (bytes == bytes_to_read)
        ioh->receive_file_complete ();
      else
        result = -1;
    }

  if (result != ACE_Filecache_Handle::ACE_SUCCESS)
    ioh->receive_file_error (result);
}

bool MgAceStreamHelper::IsConnected()
{
    bool bConnected = true;
    ACE_SOCK_Stream stream;
    stream.set_handle( m_handle );
    UINT8 dummy;
    ACE_Time_Value val(0, 0);
    ssize_t res = stream.recv_n(&dummy, 1, MSG_PEEK | MG_MSG_NOSIGNAL, &val);

    if ( res < 0 )
    {
        // Error or timeout occured
#ifdef _WIN32
        int error = ::WSAGetLastError(); // errno doesn't work correctly on Windows
        bConnected = ( error == WSAEWOULDBLOCK || error == 0 );
#else
        bConnected = ( errno == EWOULDBLOCK || errno == 0 || errno == ETIME );
#endif
    }
    else if (res == 0)
    {
        // No longer connected
        bConnected = false;
    }

    return bConnected;
}

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 handle_input(ACE_HANDLE)
	{
		if(Peer->recv_n(data, DATA_SIZE) == 0)
		{
			std::cout<<"Peer probably aborted connection";
			ACE_Thread::cancel(t_id);
			return -1;
		}
		ACE_OS::printf("<< %s\n", data);
		return 0;
	}

void read_thread(void* arg)
{
	pa_sample_spec capture_profile;
	capture_profile.channels = 1;
	capture_profile.rate = 44100;
	capture_profile.format = PA_SAMPLE_S16LE;
	int error;
	int m = *(int*)arg;
	pa_simple *paPlayHandle = pa_simple_new(NULL,"soundCard", PA_STREAM_PLAYBACK, NULL, "playback", &capture_profile, NULL, NULL, &error);
  for (int i = 0; i < m; i++)
	{
		  short buffer[2048];
		if(server.recv_n(buffer,2048) > 0)
		  pa_simple_write(paPlayHandle, buffer, 2048, &error);
	}
}

	int handle_connection(){
		for (int i = 0; i < NO_ITERATIONS; i++){
			int byte_count = 0;
			if ((byte_count = new_stream_.recv_n(data_buf_, SIZE_DATA, 0)) == -1){
				ACE_ERROR((LM_ERROR, "%p\n", "Error in recv"));
			}
			else{
				data_buf_[byte_count] = 0;
				ACE_DEBUG((LM_DEBUG, "Server received %s \n", data_buf_));
			}
		}
		if (new_stream_.close() == -1){
			ACE_ERROR((LM_ERROR,"%p\n","close"));
		}
		return 0;
	}

// sets up the dataModeSocket Stream, reads the test header infomation
// and launches a thread to handle the requested test.
static void run_server (ACE_HANDLE handle)
{
  ACE_INET_Addr cli_addr;
  // create a new stream and initialized with the handle returned by
  // accept
  ACE_SOCK_Stream * dataModeStream = new ACE_SOCK_Stream;
  dataModeStream->set_handle (handle);

  // Make sure we're not in non-blocking mode.
  if (dataModeStream->disable (ACE_NONBLOCK) == -1){
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("%p\n"),
                ACE_TEXT ("disable")));
    return;
  }
  else if (dataModeStream->get_remote_addr (cli_addr) == -1){
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("%p\n"),
                ACE_TEXT ("get_remote_addr")));
    return;
  }

  // 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 == dataModeStream->set_option(IPPROTO_SCTP, SCTP_NODELAY, &nagle, sizeof nagle)){
      ACE_ERROR((LM_ERROR,
                 ACE_TEXT ("%p\n"),
                 ACE_TEXT ("set_option")));
      return;
    }
  } else {
    // tcp case
    if (-1 == dataModeStream->set_option(IPPROTO_TCP, TCP_NODELAY, &nagle, sizeof nagle)){
      ACE_ERROR ((LM_ERROR,
                  "%p\n",
                  "set_option"));
      return;
    }
  }

  ACE_DEBUG ((LM_DEBUG,
              ACE_TEXT ("(%P|%t) client %C connected from %d\n"),
              cli_addr.get_host_name (),
              cli_addr.get_port_number ()));

  // hdr bufSize is hardcoded to 8 bytes
  // (4 for a CDR-encoded boolean and 4 for a CDR-encoded ULong)
  ACE_CDR::ULong hdrBufSize = 8;
  // allocate a raw buffer large enough to receive the header and be
  // properly aligned for the CDR decoding.
  ACE_CDR::Char * hdrBuf= new ACE_CDR::Char[hdrBufSize+ACE_CDR::MAX_ALIGNMENT];
  // align the raw buffer before reading data into it.
  char * hdrBuf_a = ACE_ptr_align_binary(hdrBuf, ACE_CDR::MAX_ALIGNMENT);

  size_t bt;
  // read the header
  if ((dataModeStream->recv_n(hdrBuf_a, hdrBufSize, 0, &bt)) == -1){
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("%p\n"),
                ACE_TEXT ("recv_n")));
    return;
  }

  // pass the CDR encoded data into an ACE_InputCDR class. hdrCDR does
  // NOT copy this data. Nor does it delete. It assumes the buffer
  // remains valid while it is in scope.
  ACE_InputCDR hdrCDR(hdrBuf_a, hdrBufSize);

  ACE_CDR::Boolean byteOrder;
  ACE_CDR::ULong numIterations;

  // extract the data
  hdrCDR >> ACE_InputCDR::to_boolean (byteOrder);
  hdrCDR.reset_byte_order(byteOrder);
  hdrCDR >> numIterations;

  // make sure the stream is good after the extractions
  if (!hdrCDR.good_bit()){
    ACE_ERROR((LM_ERROR,
               ACE_TEXT ("%p\n"),
               ACE_TEXT ("hdrCDR")));

    return;
  }

  ACE_DEBUG ((LM_DEBUG,
              ACE_TEXT ("(%P|%t) Test for %u iterations\n"),
              numIterations));

//.........这里部分代码省略.........

int ACE_TMAIN(int argc, ACE_TCHAR **argv) {

    // size and count for transmissions
    int size = 0, count = -1;

    // the server's answer is a single byte
    char answer;

    // parse the <size> argument
    if ((argc < 2) || (((size = ACE_OS::strtol(argv[1], 0, 10)) < 1) ||
            (errno == EINVAL)))
        return printUsage(argv[0]);

    // take size as the number of MiB and create appropriate buffer
    size *= BASE;
    char *someData = new (std::nothrow) char[size];

    if (someData == 0)
      ACE_ERROR_RETURN ((LM_ERROR,
                         ACE_TEXT ("%N:%l: Failed to allocate ")
                         ACE_TEXT ("data buffer.\n")), -1);

    // put someData in an auto_ptr so it gets deleted automatically
    auto_ptr<char> pSomeData(someData);

    // parse the <count> argument if available
    if ((argc == 3) && (((count = ACE_OS::strtol(argv[2], 0, 10)) < 1) ||
            (errno == EINVAL)))
        return printUsage(argv[0]);

    // the server listens on localhost on default port (from common.h)
    ACE_INET_Addr serverAddr(PORT, "localhost");

    ACE_SOCK_Stream stream;
    ACE_SOCK_Connector connector;

    // -1 is running indefinitely
    while ((count == -1) || (count-- != 0)) {

        // some output, that we know something is happening
        //ACE_DEBUG((LM_DEBUG, ACE_TEXT("%N:%l: Passes left: %i\n"), count));
        ACE_DEBUG((LM_DEBUG, ACE_TEXT(".")));

        // connect to the server and get the stream
        if (connector.connect(stream, serverAddr) == -1) {
          ACE_ERROR((LM_ERROR,
                     ACE_TEXT("%N:%l: Failed to connect to ")
                     ACE_TEXT ("server. (errno = %i: %m)\n"), ACE_ERRNO_GET));
            break;
        }

        try {

            // send the request to the server (number of MiB in the next call)
            // Note: only use the sizeof and pointer to int on compatible
            //       platforms (i.e. little-endian/big-endian, data type size)
            if (stream.send_n(&size, sizeof(size), &connTimeout) != sizeof(size)) {
                ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to  send ")
                           ACE_TEXT ("request. (errno = %i: %m)\n"), ACE_ERRNO_GET));
                throw 1;
            }

            // receive the answer
            if (stream.recv_n(&answer, sizeof(answer), &connTimeout) != 1) {
              ACE_ERROR((LM_ERROR, ACE_TEXT("%N: %l: Failed to receive ")
                         ACE_TEXT ("1st response. (errno = %i: %m)\n"), ACE_ERRNO_GET));
                throw 1;
            }

            // server answer, 'K" indicates a positive answer
            if (answer == 'K') {

                // send a huge message to the server
                if (stream.send_n(someData, size, &connTimeout) != size) {
                  ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to send ")
                             ACE_TEXT ("someData. (errno = %i: %m)\n"), ACE_ERRNO_GET));
                    throw 1;
                }

                // get an answer
                if (stream.recv_n(&answer, sizeof(answer), &connTimeout) != 1) {
                  ACE_ERROR((LM_ERROR, ACE_TEXT("%N: %l: Failed to receive ")
                             ACE_TEXT ("2nd response. (errno = %i: %m)\n"), ACE_ERRNO_GET));
                    throw 1;
                }

                // check the answer
                if (answer != 'K') {
                    cout << "The server was unable to process the data."
                         << endl;
                }
            }
        } catch (...) {
            // ok we know an error occurred, we need to close the socket.
            // The we'll try again.
        }

        // close the current stream
        if (stream.close() == -1) {
          ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to close ")
//.........这里部分代码省略.........

// 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
//.........这里部分代码省略.........

//.........这里部分代码省略.........

    // Is our internal buffer big enough?  If not, expand it.
    if ( m_readBufSize < size )
    {
        m_readBufSize = size;
        UINT8* temp = new UINT8[m_readBufSize];
        memcpy( temp, &m_readBuffer[m_readBufStart], m_readBufEnd - m_readBufStart );
        delete[] m_readBuffer;
        m_readBuffer = temp;
        m_readBufEnd -= m_readBufStart;
        m_readBufStart = 0;
    }

    //  check if requested data is already in buffer
    stat = UpdateReadBuffers( buffer, size, peeking );

    if ( MgStreamHelper::mssDone != stat )
    {
        // We do not have enough data and will need to read.  Shift buffer back
        // and attempt to fill the entire buffer with a non-blocking read first
        memmove(m_readBuffer, &m_readBuffer[m_readBufStart], m_readBufEnd-m_readBufStart);
        m_readBufEnd -= m_readBufStart;
        m_readBufStart = 0;

        ACE_SOCK_Stream stream;
        stream.set_handle( m_handle );

        // Windows has a timing problem. If trying to receive data too fast,
        // it will fail. So, use a timeout to let it catch up.
        // This workaround reduces the number of lockups significantly and
        // eliminates the hanging problem when it takes so long to write a
        // request to the socket.
        const ACE_Time_Value timeout(60);

        // On Linux, use MSG_NOSIGNAL to turn off raising of SIGPIPE on
        // stream sockets when the other end disappears.
        // Note that neither trapping the SIGPIPE signal via an
        // ACE_Event_Handler nor calling ACE_OS::signal(SIGPIPE, SIG_IGN)
        // seems to work.
        ssize_t res = stream.recv(&m_readBuffer[m_readBufEnd], m_readBufSize - m_readBufEnd, MG_MSG_NOSIGNAL, &timeout);

        if ( res < 0 )
        {
            // Check this return value to determine if the socket is closed or
            // if there was simply no data.
#ifdef _WIN32
            int error = ::WSAGetLastError(); // errno doesn't work correctly on Windows
            bool bConnected = ( error == WSAEWOULDBLOCK || error == 0 );
#else
            bool bConnected = ( errno == EWOULDBLOCK || errno == 0 || errno == ETIME );
#endif

            stat = ( bConnected ) ? MgStreamHelper::mssNotDone : MgStreamHelper::mssError;
        }
        else if (res == 0)
        {
            // No longer connected
            stat = MgStreamHelper::mssError;
        }
        else
        {
            m_readBufEnd += res;
            // Now do we have enough data?
            stat = UpdateReadBuffers( buffer, size, peeking );
        }

        if (MgStreamHelper::mssNotDone == stat && blocking)
        {
            // Still not enough data.  Have to block and fill only what was asked for.
            res = stream.recv_n(&m_readBuffer[m_readBufEnd], size - (m_readBufEnd-m_readBufStart), MG_MSG_NOSIGNAL);

            if ( res < 0 )
            {
                // Check this return value to determine if the socket is closed or
                // if there was simply no data.
#ifdef _WIN32
                int error = ::WSAGetLastError(); // errno doesn't work correctly on Windows
                bool bConnected = ( error == WSAEWOULDBLOCK || error == 0 );
#else
                bool bConnected = ( errno == EWOULDBLOCK || errno == 0 || errno == ETIME );
#endif

                stat = ( bConnected ) ? MgStreamHelper::mssNotDone : MgStreamHelper::mssError;
            }
            else if (res == 0)
            {
                // No longer connected
                stat = MgStreamHelper::mssError;
            }
            else
            {
                m_readBufEnd += res;
                // Now we better have enough data...
                stat = UpdateReadBuffers( buffer, size, peeking );
            }
        }
    }

    return stat;
}

//
// handle_input
//
int CUTS_TCPIP_Event_Handler::handle_input (ACE_HANDLE fd)
{
  // Set the ACE_HANDLE as a socket stream.
  ACE_SOCK_Stream stream (fd);


  // @todo Since the header size is constant, we can create free list
  //       of the message blocks that are used to read the header from
  //       the stream.

  // Read the event from the stream. The first chunk of the event
  // is be the header information, which is of constrant size.
  static const ssize_t header_size = 4 +        // magic
                                     4 +        // byte order
                                     2 +        // version (x.x)
                                     2 +        // padding
                                     16 +       // UUID
                                     4 +        // event id
                                     4;         // payload size

  ACE_Message_Block header (header_size);
  ssize_t retcode = stream.recv_n (header.wr_ptr (), header_size);

  if (retcode != header_size)
    ACE_ERROR_RETURN ((LM_ERROR,
           "%T (%t) - %M - invalid TCP/IP header\n"),
          -1);

  // Reflect the number of bytes read from the stream.
  header.wr_ptr (header_size);

  // Extract the header from the message block.
  CUTS_TCPIP_SPEC spec;
  ACE_CDR::ULong datasize;

  ACE_InputCDR input (header.rd_ptr (), header_size);

  // Read the SPEC and the datasize from the packet.
  input >> spec;
  input >> datasize;

  if (!input.good_bit ())
    ACE_ERROR_RETURN ((LM_ERROR,
           "%T (%t) - %M - failed to read TCP/IP header\n"),
          -1);

  // Construct a chain of message blocks to read the payload associated
  // with the received event.
  ACE_Message_Block * mb = 0;
  ACE_NEW_RETURN (mb, ACE_Message_Block (ACE_CDR::DEFAULT_BUFSIZE), -1);

  ssize_t read_count;
  ACE_Message_Block * head = mb;
  ACE_Auto_Ptr <ACE_Message_Block> auto_clean (head);

  for (size_t remaining = datasize; 0 != remaining; )
  {
    // Determine how much should be read in this attempt.
    read_count =
      ACE_CDR::DEFAULT_BUFSIZE < remaining ?
      ACE_CDR::DEFAULT_BUFSIZE : remaining;

    // Read the data from the stream.
    retcode = stream.recv_n (mb->wr_ptr (), read_count);

    if (retcode != read_count)
      ACE_ERROR_RETURN ((LM_ERROR,
                          "%T - %M - %m\n"),
                          -1);


    // Substract the amount from the remaining count.
    mb->wr_ptr (read_count);
    remaining -= read_count;

    if (0 != remaining)
    {
      // Allocate a new block for the chain.
      ACE_Message_Block * temp = 0;

      ACE_NEW_RETURN (temp,
                      ACE_Message_Block (ACE_CDR::DEFAULT_BUFSIZE),
                      -1);

      // Insert new block in the chain and move forward.
      mb->cont (temp);
      mb = temp;
    }
  }

  // Since we have made it this far, we have successfully read the
  // event and its payload from the socket. Now, pass the message
  // the object manger, so it can dispatch it accordingly.

  if (this->obj_mgr_ != 0)
  {
    iCCM::TCPIP_Servant * svnt = 0;
//.........这里部分代码省略.........

int
Measuring_Task::svc ()
{
  this->the_barrier_->wait ();

  ACE_SOCK_Stream stream;
  {
    ACE_INET_Addr remote_sap (this->endpoint_);
    ACE_SOCK_Connector connector;

    if (connector.connect(stream, remote_sap) == -1)
      {
        ACE_ERROR((LM_ERROR, "Cannot connect to <%s>\n", endpoint_));
        return -1;
      }
  }

  for (int i = 0; i != this->iterations_; ++i)
    {
      ACE_Time_Value period (0, this->period_in_usecs_);
      ACE_OS::sleep (period);

      ACE_hrtime_t start = ACE_OS::gethrtime ();
      ssize_t n = stream.send_n(&start, sizeof(start));
      if (n == 0) {
        ACE_ERROR((LM_ERROR,
                   "Connection closed while writing data to server <%s>\n",
                   endpoint_));
        break;
      } else if (n == -1) {
        ACE_ERROR((LM_ERROR,
                   "Error writing data to server <%s> %p\n",
                   endpoint_));
        break;
      }
      if (n == 0 || n == -1)
      {
        ACE_ERROR((LM_ERROR,
                   "Error sending data to server <%s>\n", endpoint_));
        break;
      }

      ACE_hrtime_t end;
      n = stream.recv_n(&end, sizeof(end));
      if (n == 0) {
        ACE_ERROR((LM_ERROR,
                   "Connection closed while reading data from server <%s>\n",
                   endpoint_));
        break;
      } else if (n == -1) {
        ACE_ERROR((LM_ERROR,
                   "Error reading data from server <%s> %p\n",
                   endpoint_));
        break;
      }

      if (start != end)
      {
        ACE_ERROR((LM_ERROR,
                   "Mismatched response from <%s>\n", endpoint_));
        return -1;
      }
      ACE_hrtime_t elapsed = ACE_OS::gethrtime () - start;

      this->sample_history.sample (elapsed);
    }

  stream.close();

  return 0;
}

int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
  parse_args (argc, argv);
  ACE_INET_Addr sa (port_number, host_name);
  void *cp;
  char buf[BUFSIZ];
  int n;
  ACE_SOCK_CODgram dc;

  if (dc.open (sa, ACE_Addr::sap_any) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "open"),
                      -1);

  // First send the name of the file as a datagram.

  iovec iov[2];

  iov[0].iov_base = (char *) "filename: ";
  iov[0].iov_len  = 11;
  iov[1].iov_base = (char *) file_name;
  iov[1].iov_len  = ACE_OS::strlen (file_name);

  if (dc.send (iov, 2) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "send"),
                      -1);

  ACE_SOCK_Stream sc;
  ACE_SOCK_Connector con;

  if (con.connect (sc, sa) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "connect"),
                      -1);

  ACE_Mem_Map mmap (file_name);

  if (mmap (cp) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "mmap"),
                      -1);

  // Next, send the file's contents.

  if (sc.send_n (cp, mmap.size ()) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "send_urg"),
                      -1);

  if (sc.close_writer () == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "close_writer"),
                      -1);

  if ((n = sc.recv_n (buf, sizeof buf)) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "recv"),
                      -1);
  else
    ACE_OS::write (ACE_STDOUT, buf, n);

  return 0;
}