C++ ACE_Message_Block::size方法代码示例

int
Simple_Tester::initiate_read_file (void)
{
  // Create Message_Block
  ACE_Message_Block *mb = 0;
  ACE_NEW_RETURN (mb, ACE_Message_Block (BUFSIZ + 1), -1);

  // Inititiate an asynchronous read from the file
  if (this->rf_.read (*mb,
		      mb->size () - 1) == -1)
    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_Asynch_Read_File::read"), -1);

  ACE_DEBUG ((LM_DEBUG,
              "Simple_Tester:initiate_read_file: Asynch Read File issued sucessfully\n"));

  return 0;
}

int
Receiver::initiate_read_stream (void)
{
  // Create a new <Message_Block>.  Note that this message block will
  // be used both to <read> data asynchronously from the socket and to
  // <write> data asynchronously to the file.
  ACE_Message_Block *mb = 0;
  ACE_NEW_RETURN (mb,
                  ACE_Message_Block (BUFSIZ + 1),
                  -1);

  // Inititiate read
  if (this->rs_.read (*mb,
                      mb->size () - 1) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "ACE_Asynch_Read_Stream::read"),
                      -1);
  return 0;
}

int AC_Output_Handler::svc () {
  ACE_Message_Block *chunk[ACE_IOV_MAX];
  size_t message_index = 0;
  ACE_Time_Value time_of_last_send (ACE_OS::gettimeofday ());
  ACE_Time_Value timeout;
  ACE_Sig_Action no_sigpipe ((ACE_SignalHandler) SIG_IGN);
  ACE_Sig_Action original_action;
  no_sigpipe.register_action (SIGPIPE, &original_action);

  for (;;) {
    if (message_index == 0) {
      timeout = ACE_OS::gettimeofday ();
      timeout += FLUSH_TIMEOUT;
    }
    ACE_Message_Block *mblk = 0;
    if (getq (mblk, &timeout) == -1) {
      if (errno == ESHUTDOWN) {
        if (connector_->reconnect () == -1) break;
        continue;
      } else if (errno != EWOULDBLOCK) break;
      else if (message_index == 0) continue;
    } else {
      if (mblk->size () == 0
          && mblk->msg_type () == ACE_Message_Block::MB_STOP)
        { mblk->release (); break; }
      chunk[message_index] = mblk;
      ++message_index;
    }
    if (message_index >= ACE_IOV_MAX ||
        (ACE_OS::gettimeofday () - time_of_last_send
         >= ACE_Time_Value(FLUSH_TIMEOUT))) {
      if (this->send (chunk, message_index) == -1) break;
      time_of_last_send = ACE_OS::gettimeofday ();
    }
  }

  if (message_index > 0)
    this->send (chunk, message_index);
  no_sigpipe.restore_action (SIGPIPE, original_action);
  return 0;
}

int
STDIN_Handler::svc (void)
{
  this->register_thread_exit_hook ();

  for (;;)
    {
      ACE_Message_Block *mb = new ACE_Message_Block (BUFSIZ);

      // Read from stdin into mb.
      int read_result = ACE_OS::read (ACE_STDIN,
                                      mb->rd_ptr (),
                                      mb->size ());

      // If read succeeds, put mb to peer handler, else end the loop.
      if (read_result > 0)
        {
          mb->wr_ptr (read_result);
          // Note that this call will first enqueue mb onto the peer
          // handler's message queue, which will then turn around and
          // notify the Reactor via the Notification_Strategy.  This
          // will subsequently signal the Peer_Handler, which will
          // react by calling back to its handle_output() method,
          // which dequeues the message and sends it to the peer
          // across the network.
          this->ph_.putq (mb);
        }
      else
        {
          mb->release ();
          break;
        }
    }

  // handle_signal will get called on the main proactor thread since
  // we just exited and the main thread is waiting on our thread exit.
  return 0;
}

static void *
producer (ACE_Message_Queue<ACE_MT_SYNCH> *msg_queue)
{
  // Keep reading stdin, until we reach EOF.

  for (int n; ; )
    {
      // Allocate a new message.
      ACE_Message_Block *mb = 0;

      ACE_NEW_RETURN (mb, ACE_Message_Block (BUFSIZ), 0);

      n = ACE_OS::read (ACE_STDIN, mb->wr_ptr (), mb->size ());

      if (n <= 0)
        {
          // Send a shutdown message to the other thread and exit.
          mb->length (0);
          if (msg_queue->enqueue_tail (mb) == -1)
            ACE_ERROR ((LM_ERROR,
                        "(%t) %p\n",
                        "put_next"));
          break;
        }
      // Send the message to the other thread.
      else
        {
          mb->msg_priority (n);
          mb->wr_ptr (n);
          if (msg_queue->enqueue_tail (mb) == -1)
            ACE_ERROR ((LM_ERROR,
                        "(%t) %p\n",
                        "put_next"));
        }
    }

  return 0;
}

int KSG_Reactor_Handler::handle_input(ACE_HANDLE handle)
{
	ACE_Message_Block *mb;
	if(!_message)
	{
		ACE_NEW_RETURN(mb,ACE_Message_Block(BUFSIZ+1),-1);
	}
	int ret;
	ssize_t bytes_read = 0;
	do
	{
		ret = 0;
		bytes_read = this->peer().recv(mb->wr_ptr(),mb->size() - mb->length());
		if(bytes_read == -1)
		{
			if(errno == EWOULDBLOCK)
			{
				break;
			}
			else
			{
				mb->release();
				mb = NULL;
				ACE_ERROR((LM_ERROR,"½ÓÊÕÊý¾Ýʧ°Ü£¡£¡"));
				ret = -1;
				break;
			}
		}
		else if(bytes_read == 0)
		{
			break;
		}
	} while(1);
	
	_message = mb;
	return ret;
}

template <class ROUTER, class KEY> int
Peer_Handler<ROUTER, KEY>::handle_input (ACE_HANDLE h)
{

  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) input arrived on sd %d\n"), h));
//  ACE_Reactor::instance ()->remove_handler(h,
//                                          ACE_Event_Handler::ALL_EVENTS_MASK
//                                          |ACE_Event_Handler::DONT_CALL);
// this method should be called only if the peer shuts down
// so we deactivate our ACE_Message_Queue to awake our svc thread

  return 0;

#if 0
  ACE_Message_Block *db = new ACE_Message_Block (BUFSIZ);
  ACE_Message_Block *hb = new ACE_Message_Block (sizeof (KEY), ACE_Message_Block::MB_PROTO, db);
  int           n;

  if ((n = this->peer ().recv (db->rd_ptr (), db->size ())) == -1)
    ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("recv failed")), -1);
  else if (n == 0) // Client has closed down the connection.
    {
      if (this->router_task_->unbind_peer (this->get_handle ()) == -1)
        ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"),
                           ACE_TEXT ("unbind failed")), -1);
      ACE_DEBUG ((LM_DEBUG, "(%t) shutting down %d\n", h));
      return -1; // Instruct the ACE_Reactor to deregister us by returning -1.
    }
  else // Transform incoming buffer into a Message and pass downstream.
    {
      db->wr_ptr (n);
      *(long *) hb->rd_ptr () = this->get_handle (); // structure assignment.
      hb->wr_ptr (sizeof (long));
      return this->router_task_->reply (hb) == -1 ? -1 : 0;
    }
#endif
}

static void *
consumer (void *)
{
  ACE_UPIPE_Stream c_stream;

  // Set the high water mark to size to achieve optimum performance.

  int wm = size * iterations;

  if (c_stream.control (ACE_IO_Cntl_Msg::SET_HWM,
                        &wm) == -1)
    ACE_DEBUG ((LM_DEBUG,
                "set HWM failed\n"));

  ACE_UPIPE_Addr serv_addr (ACE_TEXT("pattern"));

  // accept will wait up to 4 seconds
  ACE_UPIPE_Acceptor acc (serv_addr);

  ACE_DEBUG ((LM_DEBUG,
              "(%t) consumer spawning the supplier thread\n"));

  // Spawn the supplier thread.
  if (ACE_Thread_Manager::instance ()->spawn (ACE_THR_FUNC (supplier),
                                              (void *) 0,
                                              THR_NEW_LWP | THR_DETACHED) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "spawn"),
                      0);

  ACE_DEBUG ((LM_DEBUG,
              "(%t) consumer starting accept\n"));

  if (acc.accept (c_stream) == -1)
    ACE_ERROR ((LM_ERROR,
                "(%t) %p\n",
                "ACE_UPIPE_Acceptor.accept failed"));

  // Time measurement.
  time_t currsec;
  ACE_OS::time (&currsec);
  time_t start = (time_t) currsec;

  int received_messages = 0;

  for (ACE_Message_Block *mb = 0;
       c_stream.recv (mb) != -1 && mb->size () != 0;
       mb->release ())
    received_messages++;

  ACE_OS::time (&currsec);
  time_t secs = (time_t) currsec - start;

  ACE_DEBUG ((LM_DEBUG,
              "(%t) Transferred %d blocks of size %d\n"
              "The program ran %d seconds\n",
              received_messages, size, secs));
  c_stream.close ();
  return 0;
}

int SerialportTask::svc (void)
{
    ACE_DEBUG((LM_DEBUG,
                "Create zigbee serialport Service thread\n"));

    ACE_Time_Value last_time = ACE_OS::gettimeofday();
    ACE_Time_Value current_time = ACE_OS::gettimeofday();

    while( !thread_exit_flag)
    {
        ACE_Message_Block *b = 0;

        if (message_queue.dequeue_head(b) == -1 )
        {
            ACE_DEBUG((LM_DEBUG, "faile get block from queue\n"));
            continue;
        }

        //ACE_DEBUG((LM_DEBUG, "*** get type[%x] size[%d] ****\n", b->msg_type(),
        //message_queue.message_count()));

        switch(b->msg_type())
        {
            case ZIGBEE_SERIAL_PORT_CMD_EXIT_THREAD:
            {
                thread_exit_flag = 1;
            }
            break;

            case ZIGBEE_SERIAL_PORT_CMD_CONNECT_PORT:
            {
               owner_->connecting_serial_port();
            }
            break;

            case ZIGBEE_SERIAL_PORT_CMD_SEND_REQ:
            {
               current_time = ACE_OS::gettimeofday();

               // each command cant send togather. when the time expired
               // send it
               if ( current_time.msec() > last_time.msec() + 1500 )
               {
                    owner_->send_req((unsigned char*)b->base(), b->size());

                    last_time = ACE_OS::gettimeofday();
               }
               else
               {
                    // re-enter queue to wait time expired
                    message_queue.enqueue_tail(b);
                    b = 0;
               }

            }
            break;

            case ZIGBEE_SERIAL_PORT_CMD_GET_RES:
            {
                owner_->get_response();
            }
            break;

            default:
                break;

        }

        if (b)
        {
            b->release();
        }
    }

    ACE_DEBUG((LM_DEBUG,
                "Return from zigbee serialport Service thread\n"));

    return 0;

}

int
device_averager::handle_timeout( const ACE_Time_Value& tv, const void * )
{
    if ( state() <= device_state::state_initializing )
        doit( device_state::command_stop );

    if ( uptime_.sec() == 0 && uptime_.usec() == 0 )
        uptime_ = tv;
    
    size_t hLen = 32;
    size_t nbrSamples = 1024 * 15;
    size_t nbrAverage = 1;
    size_t sampInterval = 500;
    size_t nDelay = 12 * 1000000 / 500;
    unsigned long wellKnownEvents = 0;

	static size_t npos;

	const std::vector< TXTSpectrum > spectra = device_emulator::singleton::device_facade::instance()->test_spectra();
    const TXTSpectrum * psp = 0;
	if ( ! spectra.empty() ) {
		const TXTSpectrum& sp = spectra[0];
		nbrSamples = sp.iarray_.size();
        sampInterval = sp.sampInterval_;
        nDelay = sp.startDelay_;
		psp = &sp;
	}
	size_t wformLen = (nbrSamples * 3 / 4) + 1; // 32bit -> 24bit 

	ACE_Message_Block * mb = new ACE_Message_Block( adportable::protocol::LifeCycle::wr_offset() + ((hLen + wformLen) * sizeof(long)));
	size_t size = mb->size();
	memset( mb->wr_ptr(), 0, size );
	mb->wr_ptr( adportable::protocol::LifeCycle::wr_offset() );

	long * pmeta = reinterpret_cast<long *>(mb->wr_ptr());
	// long * pdata = pmeta + hLen;
    unsigned char * pchar = reinterpret_cast<unsigned char *>( pmeta + hLen );
	mb->wr_ptr( mb->size() );

    ACE_Time_Value tm = tv - uptime_;
    unsigned long long uptime = tm.sec() * 1000000 + tm.usec();

	*pmeta++ = TOFConstants::ClassID_ProfileData;
	*pmeta++ = npos++;
	*pmeta++ = unsigned long ( uptime & 0xffffffff ); // time since inject, to do
	*pmeta++ = unsigned long ( uptime & 0xffffffff );
	*pmeta++ = unsigned long ( uptime >> 32 );
	*pmeta++ = nbrSamples;
    *pmeta++ = nbrAverage;
	*pmeta++ = nDelay;
	*pmeta++ = sampInterval;
    *pmeta++ = wellKnownEvents;

	// simulate noise
	srand( int(tv.sec()) );

	if ( psp ) {
		double f = 1000.0 / psp->maxValue_;
		for ( size_t i = 0; i < nbrSamples; ++i ) {
            double d = psp->iarray_[i] + (psp->maxValue_ / 20.0);
			if ( d < (-psp->maxValue_ / 20) )
				d = (-psp->maxValue_ / 20);
			long x = ( d * f ) + ( double(rand()) * 10 / RAND_MAX );
			*pchar++ = x >> 16;
			*pchar++ = x >> 8;
            *pchar++ = x;
		}
	}
	// todo: overlay chemical background, and sample peak
	mb->msg_type( constants::MB_DATA_TO_CONTROLLER );
	singleton::device_facade::instance()->putq( mb );

	return 0;
}

int HDCCUSvrHandler::svc()
{
#define MES_DATA_HEAD_LEN 2

    ACE_DEBUG((LM_DEBUG,"ACE 打开连接............"));
    ACE_Message_Block * mb = NULL;

    ACE_Time_Value tv(5);
    if (this->getq(mb,&tv) == -1) return -1;
    HD8583STRUCT req;
    HD8583STRUCT resp;
    MESSAGETYPE msg_type;
    char * buffer = mb->rd_ptr();
    int len = 0;
    // 数据段长度超过允许范围,忽略请求
    if(UnPackResponseStruct(req,&msg_type,buffer,mb->length()) != 0)
    {
        ACE_ERROR((LM_ERROR,"数据包不合法"));
        mb->release();
        return -1;
    }

    ACE_HEX_DUMP((LM_DEBUG,mb->rd_ptr(),mb->length()));
    try
    {
        HDResponseHandler* handler = HDCCUProcessUnits::Instance().Create(msg_type);
        if(handler)
        {
            resp.Init();

            int result = handler->DoResponse(req,resp,peer().get_handle());
            if(result > 0)
            {
                // send back
                mb->reset();
                buffer = mb->wr_ptr();
                len = (int)PackRequestStruct(resp,msg_type,buffer,mb->size());
                mb->wr_ptr(len);
                ACE_HEX_DUMP((LM_DEBUG,buffer,mb->length()));
                ACE_DEBUG((LM_DEBUG,"数据包长度[%d]",mb->length()));
                if(peer().send_n(mb->rd_ptr(),mb->length()) <=0 )
                {
                    ACE_DEBUG((LM_ERROR,"发送应答包失败"));
                }

            }
            else if(result == 0)
            {
                // OK
                ACE_DEBUG((LM_DEBUG,"处理成功"));
            }
            else
            {
                // error
                ACE_DEBUG((LM_ERROR,"处理请求失败，返回码[%d]",result));
            }
        }
        else
        {
            ACE_ERROR((LM_ERROR,"不能处理请求代码[%c]",msg_type));
        }
    }
    catch(...)
    {
        // 捕获所有的异常
        ACE_ERROR((LM_ERROR,"处理请求异常,请求代码[%02x]",msg_type));
    }
    mb->release();
    return 0;
}

int
JAWS_Parse_Headers::parse_headers (JAWS_Header_Info *info,
                                   ACE_Message_Block &mb)
{
  for (;;)
    {
      if (mb.rd_ptr () == mb.wr_ptr ())
          break;

      char *p = mb.rd_ptr ();

      if (info->end_of_line ()
          && (*p != ' ' && *p != '\t'))
        {
          int r = this->parse_header_name (info, mb);
          if (r == 1)
            return info->end_of_headers ();
          continue;
        }
      else
        {
          int r = this->parse_header_value (info, mb);
          if (r == 1)
            {
              if (info->end_of_headers ())
                return 1;
              break;
            }
          continue;
        }
    }

  // If we arrive here, it means either there is nothing more to read,
  // or parse_header_value ran into difficulties (like maybe the
  // header value was too long).

  if (mb.rd_ptr () != mb.base ())
    {
      mb.crunch ();
      return 0;
    }
  else if (mb.length () < mb.size ())
    {
      return 0;
    }
  else if (mb.length () == mb.size ())
    {
      // This is one of those cases that should rarely ever happen.
      // If we get here, the header type name is over 8K long.  We
      // flag this as a bad thing.

      // In HTTP/1.1, I have to remember that a bad request means the
      // connection needs to be closed and the client has to
      // reinitiate the connection.

      info->status (JAWS_Header_Info::STATUS_CODE_TOO_LONG);
      return 1;
    }
  else if (mb.length () > mb.size ())
    {
      ACE_DEBUG ((LM_DEBUG, "JAWS_Parse_Headers: buffer overrun!!\n"));
      info->status (JAWS_Header_Info::STATUS_CODE_TOO_LONG);
      return 1;
    }

  ACE_DEBUG ((LM_DEBUG, "JAWS_Parse_Headers -- shouldn't be here!\n"));
  return 1;
}

int
Peer_Handler::handle_input (ACE_HANDLE h)
{
  ACE_DEBUG ((LM_DEBUG,
              ACE_TEXT ("(%t) input arrived on handle %d\n"),
              h));

  ACE_Message_Block *db;

  ACE_NEW_RETURN (db, ACE_Message_Block (BUFSIZ), -1);

  ACE_Message_Block *hb = new ACE_Message_Block (sizeof (ROUTING_KEY),
                                                 ACE_Message_Block::MB_PROTO, db);
  // Check for memory failures.
  if (hb == 0)
    {
      db->release ();
      errno = ENOMEM;
      return -1;
    }

  ssize_t n = this->peer ().recv (db->rd_ptr (),
                                  db->size ());

  if (n == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       ACE_TEXT ("%p"),
                       ACE_TEXT ("recv failed")),
                      -1);
  else if (n == 0) // Client has closed down the connection.
    {
      if (this->peer_router_context_->unbind_peer (this->get_handle ()) == -1)
        ACE_ERROR_RETURN ((LM_ERROR,
                           ACE_TEXT ("%p"),
                           ACE_TEXT ("unbind failed")),
                          -1);

      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("(%t) shutting down handle %d\n"), h));
      // Instruct the <ACE_Reactor> to deregister us by returning -1.
      return -1;
    }
  else
    {
      // Transform incoming buffer into an <ACE_Message_Block>.

      // First, increment the write pointer to the end of the newly
      // read data block.
      db->wr_ptr (n);

      // Second, copy the "address" into the header block.  Note that
      // for this implementation the HANDLE we receive the message on
      // is considered the "address."  A "real" application would want
      // to do something more sophisticated.
      *(ACE_HANDLE *) hb->rd_ptr () = this->get_handle ();

      // Third, update the write pointer in the header block.
      hb->wr_ptr (sizeof (ACE_HANDLE));

      // Finally, pass the message through the stream.  Note that we
      // use <Task::put> here because this gives the method at *our*
      // level in the stream a chance to do something with the message
      // before it is sent up the other side.  For instance, if we
      // receive messages in the <Supplier_Router>, it will just call
      // <put_next> and send them up the stream to the
      // <Consumer_Router> (which broadcasts them to consumers).
      // However, if we receive messages in the <Consumer_Router>, it
      // could reply to the Consumer with an error since it's not
      // correct for Consumers to send messages (we don't do this in
      // the current implementation, but it could be done in a "real"
      // application).

      if (this->peer_router_context_->peer_router ()->put (hb) == -1)
        return -1;
      else
        return 0;
    }
}

int
MP_Worker::svc(void)
{
	ACE_DEBUG((LM_DEBUG, ACE_TEXT ("(%t) starting up \n")));
	ACE_Message_Block* mb;

	MIME_Entity e;

	int n_eml_http_1 = 0;
	int n_eml_http_n = 0;
	int n_eml_phone = 0;
	FILE* fp;
	fp = ::fopen("d:\\_spam_\\http.log", "w");

	// pattern hash
	std::set< ACE_UINT32 > pat_set;
	int n_dup = 0;

	while(this->msg_queue()->dequeue_head(mb) != -1)
	{
		if ( ACE_OS::strlen(mb->base()) == 0 )
		{
			ACE_DEBUG(( 
				LM_DEBUG, 
				ACE_TEXT("(%t) shutting down\n")
				));
			break;
		}

		///*
		ACE_DEBUG(( 
			LM_DEBUG, 
			ACE_TEXT("(%t) %s\n"), 
			(mb->base())
			));
		//*/

		//::printf("open eml:%s\n", mb->base());
		fwrite(mb->base(), mb->size()-1, 1, fp); // mb->size()-1 to trim '\0' at the end
		fwrite("\n", 1, 1, fp);

		FILE* fp2 = ::fopen("d:\\_spam_\\_log_\\utf-8.txt", "a");
		//fwrite("\xEF\xBB\xBF", 3, 1, fp2);
		::fwrite(mb->base(), mb->size()-1, 1, fp2); // mb->size()-1 to trim '\0' at the end
		::fwrite("\r\n", 2, 1, fp2);
		::fclose(fp2);

		e.import_file(mb->base());
		//e.dump();
		//e.dump_body();

		std::set< std::string > url_set;
		//MIME_Analyzer::get_url(e, url_set);
		//MIME_Analyzer::get_phone(e);
		MIME_Analyzer::dump_body(e); // also log utf-8 txt in this function
		//getchar();

		///*
		// handle dup pattern hash
		ACE_UINT32 hash_val = MIME_Analyzer::get_hash(e);
		if ( pat_set.find(hash_val) != pat_set.end() )
		{
			std::string dup_file(ACE::basename(mb->base(), '/'));
			char prefix[10];
			::sprintf(prefix, "%.8X_", hash_val);
			prefix[9] = 0;
			dup_file = prefix + dup_file;
			dup_file = "d:/_spam_/_dup_/" + dup_file;

			//ACE_OS::rename(mb->base(), dup_file.c_str());
			ACE_OS::unlink(mb->base());

			++n_dup;
			//::printf("%s\n", dup_file.c_str());
		}
		else
		{
			pat_set.insert(hash_val);
		}
		//*/

		// display url_set
		if ( !url_set.empty() )
		{
			//printf("n_url: %d\n", url_set.size());
			std::set< std::string >::iterator iter;
			for(iter = url_set.begin(); iter != url_set.end(); ++iter)
			{
				//printf("%s\n", (*iter).c_str());
				fwrite((*iter).c_str(), (*iter).size(), 1, fp);
				fwrite("\n", 1, 1, fp);
			}
			fwrite("\n", 1, 1, fp);

			if ( url_set.size() == 1 ) ++n_eml_http_1;
			else ++n_eml_http_n;
		}
		else
		{
			//if ( MIME_Util::get_phone(e) > 0 ) ++n_eml_phone;
//.........这里部分代码省略.........

int
Receiver::open_addr (const ACE_INET_Addr &localAddr)
{
  ACE_DEBUG ((LM_DEBUG,
              "%N:%l:Receiver::open_addr called\n"));

  // Create a local UDP socket to receive datagrams.
  if (this->sock_dgram_.open (localAddr) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "ACE_SOCK_Dgram::open"), -1);

  // Initialize the asynchronous read.
  if (this->rd_.open (*this,
                      this->sock_dgram_.get_handle (),
                      this->completion_key_,
                      ACE_Proactor::instance ()) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       "%p\n",
                       "ACE_Asynch_Read_Dgram::open"), -1);

  // Create a buffer to read into.  We are using scatter/gather to
  // read the message header and message body into 2 buffers

  // create a message block to read the message header
  ACE_Message_Block* msg = 0;
  ACE_NEW_RETURN (msg, ACE_Message_Block (1024), -1);

  // the next line sets the size of the header, even though we
  // allocated a the message block of 1k, by setting the size to 20
  // bytes then the first 20 bytes of the reveived datagram will be
  // put into this message block.
  msg->size (20); // size of header to read is 20 bytes

  // create a message block to read the message body
  ACE_Message_Block* body = 0;
  ACE_NEW_RETURN (body, ACE_Message_Block (1024), -1);
  // The message body will not exceed 1024 bytes, at least not in this test.

  // set body as the cont of msg.  This associates the 2 message
  // blocks so that a read will fill the first block (which is the
  // header) up to size (), and use the cont () block for the rest of
  // the data.  You can chain up to IOV_MAX message block using this
  // method.
  msg->cont (body);

  // ok lets do the asynch read
  size_t number_of_bytes_recvd = 0;

  int res = rd_.recv (msg,
                      number_of_bytes_recvd,
                      0,
                      PF_INET,
                      this->act_);
  switch (res)
    {
    case 0:
      // this is a good error.  The proactor will call our handler when the
      // read has completed.
      break;
    case 1:
      // actually read something, we will handle it in the handler callback
      ACE_DEBUG ((LM_DEBUG, "********************\n"));
      ACE_DEBUG ((LM_DEBUG,
                  "%s = %d\n",
                  "bytes recieved immediately",
                  number_of_bytes_recvd));
      ACE_DEBUG ((LM_DEBUG, "********************\n"));
      res = 0;
      break;
    case -1:
      // Something else went wrong.
      ACE_ERROR ((LM_ERROR,
                  "%p\n",
                  "ACE_Asynch_Read_Dgram::recv"));
      // the handler will not get called in this case so lets clean up our msg
      msg->release ();
      break;
    default:
      // Something undocumented really went wrong.
      ACE_ERROR ((LM_ERROR,
                  "%p\n",
                  "ACE_Asynch_Read_Dgram::recv"));
      msg->release ();
      break;
    }

  return res;
}