Example #1
0
int RASocket::recv_line(ACE_Message_Block& buffer)
{
    char byte;
    for (;;)
    {
        ssize_t n = peer().recv(&byte, sizeof(byte));

        if (n < 0)
        {
            return -1;
        }

        if (n == 0)
        {
            // EOF, connection was closed
            errno = ECONNRESET;
            return -1;
        }

        ACE_ASSERT(n == sizeof(byte));

        if (byte == '\n')
            break;
        else if (byte == '\r') /* Ignore CR */
            continue;
        else if (buffer.copy(&byte, sizeof(byte)) == -1)
            return -1;
    }

    const char null_term = '\0';
    if (buffer.copy(&null_term, sizeof(null_term)) == -1)
        return -1;

    return 0;
}
Example #2
0
int UDPGenerator::rescuerHandSake(
    const ACE_TCHAR * remotehost,
    u_short remoteport)
{
    ACE_DEBUG ((LM_DEBUG, "Sender::initiate_write called\n"));
    const size_t max_payload_size = 4 + ACE_CDR::MAX_ALIGNMENT; //pading

    u_short myid = htons(5);
    u_short mysize = htons(0);

    ACE_Message_Block* body = 0;
    ACE_NEW_RETURN(body, ACE_Message_Block(4), -1);
    body->copy((const char *)&myid, 2);
    body->copy((const char *)&mysize, 2);

    size_t number_of_bytes_sent = 0;
    ACE_INET_Addr serverAddr(remoteport, remotehost);
    int res = this->wd_.send(
                  body, number_of_bytes_sent,
                  0,
                  serverAddr,
                  this->act_);

    switch (res)
    {
    case 0:
        // this is a good error.  The proactor will call our handler when the
        // send has completed.
        break;
    case 1:
        // actually sent something, we will handle it in the handler callback
        ACE_DEBUG ((LM_DEBUG, "********************\n"));
        ACE_DEBUG ((LM_DEBUG,
                    "%s = %d\n",
                    "bytes sent immediately",
                    number_of_bytes_sent));
        ACE_DEBUG ((LM_DEBUG, "********************\n"));
        res = 0;
        break;
    case -1:
        // Something else went wrong.
        ACE_ERROR ((LM_ERROR,
                    "%p\n",
                    "ACE_Asynch_Write_Dgram::recv"));
        // the handler will not get called in this case so lets clean up our msg
        body->release ();
        break;
    default:
        // Something undocumented really went wrong.
        ACE_ERROR ((LM_ERROR,
                    "%p\n",
                    "ACE_Asynch_Write_Dgram::recv"));
        body->release ();
        break;
    }
    return res;
}
Example #3
0
int
Sender::initiate_write_stream ()
{
  if (this->flg_cancel_ != 0)
    {
      return -1;
    }

  if (this->get_ref_cnt_w() != 0)
    {
      return 0; // todo: queue it
    }


  u_int blksize = this->config().s_blksize();
  u_int limit   = this->config().xfer_limit();
  u_int winsize = this->config().w_size();

  if (limit != 0 && this->total_snd_ >= limit)
    {
      this->shutdown_i ();
      return 0;
    }

  u_long delta = this->total_snd_- this->total_rcv_;
  if (delta > winsize)
     return 0;

  ACE_Message_Block *mb = 0;

  ACE_NEW_RETURN (mb,
                  ACE_Message_Block (blksize+1),
                  -1);

  mb->copy(complete_message);
  mb->copy("\0");
  mb->wr_ptr(mb->base() + blksize);
 

  if (this->stream_.write (*mb, mb->length ()) == -1)
    {
      mb->release ();
      this->cancel_i();
      return -1;
    }

  this->ref_cnt_w_++;
  this->total_w_++;
  return 0;
}
Example #4
0
int WorldSocket::SendPacket(WorldPacket const& pct)
{
    ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);

    if (closing_)
        return -1;

    // Dump outgoing packet.
    if (sPacketLog->CanLogPacket())
        sPacketLog->LogPacket(pct, SERVER_TO_CLIENT);

    // Create a copy of the original packet; this is to avoid issues if a hook modifies it.
    sScriptMgr->OnPacketSend(this, WorldPacket(pct));

    Flexi::ServerPktHeader header(pct.size()+2, pct.GetOpcode());
    m_Crypt.EncryptSend ((uint8*)header.header, header.getHeaderLength());

    if (m_OutBuffer->space() >= pct.size() + header.getHeaderLength() && msg_queue()->is_empty())
    {
        // Put the packet on the buffer.
        if (m_OutBuffer->copy((char*) header.header, header.getHeaderLength()) == -1)
            ACE_ASSERT (false);

        if (!pct.empty())
            if (m_OutBuffer->copy((char*) pct.contents(), pct.size()) == -1)
                ACE_ASSERT (false);
    }
    else
    {
        // Enqueue the packet.
        ACE_Message_Block* mb;

        ACE_NEW_RETURN(mb, ACE_Message_Block(pct.size() + header.getHeaderLength()), -1);

        mb->copy((char*) header.header, header.getHeaderLength());

        if (!pct.empty())
            mb->copy((const char*)pct.contents(), pct.size());

        if (msg_queue()->enqueue_tail(mb, (ACE_Time_Value*)&ACE_Time_Value::zero) == -1)
        {
            sLog->outError("WorldSocket::SendPacket enqueue_tail failed");
            mb->release();
            return -1;
        }
    }

    return 0;
}
int Test_Service_Handler::send()
{
  ACE_Guard<ACE_Recursive_Thread_Mutex> guard(mtx_);

  ACE_DEBUG ((LM_DEBUG, 
      ACE_TEXT("(%t) %s_Handler(%@)::send() fd=%d\n"),
      is_caller_ ? "Client" : "Server" ,
      this,
      this->handle()));

  //AL:
  if (!cancel_called_)
  {
     //AL: not thread safe
     //static std::string pkt = pkt_header;
     //pkt += pkt_payload;

     size_t len_header  = ACE_OS::strlen(pkt_header);
     size_t len_payload = ACE_OS::strlen(pkt_payload);

     ACE_Message_Block *mb = 0;

     ACE_NEW_RETURN(mb, ACE_Message_Block(len_header+len_payload), -1);

     mb->copy(pkt_header, len_header);
     mb->copy(pkt_payload, len_payload);
    
     int ret = writer_.write(*mb, mb->length());
     if (ret == 0)
     {
        write_count_++;
        return 0;
     }

     mb->release();

  }

  ACE_DEBUG ((LM_DEBUG,
      ACE_TEXT("(%t) %s_Handler(%@)::send failed\n"),
      is_caller_ ? "Client" : "Server" ,
      this));

  //AL: delete_if_reqd();
  this->cancel();

  return -1;
}
Example #6
0
int
PSession::initiate_write (u_long offset_low, u_long offset_high,
                          const char * data, 
                          size_t len)
{
    ACE_Message_Block *mb = 0;

    u_int blksize = this->config().s_blksize();

    if (blksize < len)
    {
        blksize=len;
    }
    ACE_NEW_RETURN (mb,
        ACE_Message_Block (blksize),
        -1);

    if (mb == 0)
    {
        this->do_cancel ();
        return -1;
    }

    mb->reset ();
    mb->copy (data, len);
    //mb->wr_ptr (mb->space());
    return this->initiate_write (offset_low, offset_high, *mb);
}
Example #7
0
int
ACE_RMCast_Fragment_Tester::compare (ACE_Message_Block *mb)
{
  size_t n = mb->total_size ();
  ACE_Message_Block blob (n);

  for (const ACE_Message_Block *i = mb; i != 0; i = i->cont ())
    {
      blob.copy (i->rd_ptr (), i->length ());
    }

  if (ACE_OS::memcmp (blob.rd_ptr (),
                      this->received_.rd_ptr (),
                      n) != 0)
    {
      for (size_t offset = 0; offset < n; offset += 256)
        {
          size_t z = 256;
          if (n - offset < 256)
            z = n - offset;
          ACE_HEX_DUMP ((LM_DEBUG,
                         blob.rd_ptr () + offset,
                         z,
                         ACE_TEXT ("BIG BLOB")));
          ACE_HEX_DUMP ((LM_DEBUG,
                         this->received_.rd_ptr () + offset,
                         z,
                         ACE_TEXT ("RECEIVED")));
        }
      return -1;
    }
  return 0;
}
//  Implement its handle_input() hook method to perform the "Half-Async" 
int Echo_Svc_Handler::handle_input(ACE_HANDLE)
{
  ACE_DEBUG((LM_DEBUG,
	     "(%t) Echo_Svc_Handler::handle_input\n"));


  // Reads the client data [ACE_SOCK_Stream] until the end of a line is reached
  char buf[ACE_DEFAULT_MAX_SOCKET_BUFSIZ];
  ssize_t recv_cnt;

  recv_cnt = this->peer().recv(buf, sizeof(buf));
  if (recv_cnt <= 0) {
    ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t) connection closed \n")));
    return -1;
  }

  // Puts the client data into a message [ACE_Message_Block]
  ACE_Message_Block *mb = 0;
  ACE_NEW_RETURN(mb,
		 ACE_Message_Block(recv_cnt),
		 -1);

  mb->copy(buf, recv_cnt);

  // Calls Echo_Task::put(), which uses ACE_Task::putq() to enqueue the message 
  // for subsequent processing by a thread in the pool of threads that are running
  // the Echo_Task::svc() hook method.  
  echo_task_->putq(mb);

  return 0;
}
Example #9
0
    virtual int svc () 
    {  	   
  	   //int  i =0;
  	   ACE_Message_Block *mblk;  	   
	   int  len = 0;
	   
       while(!fin.eof())
      {      	 
      	 fin.getline(file_buf, LineSize);      	 
      	 len = ACE_OS::strlen( file_buf );
         ACE_NEW_RETURN (mblk, ACE_Message_Block (len+200), 0);
         if (file_buf[len-1] == '\r')
         {
         	len = len - 1;
         }          
	     mblk->copy (file_buf, len+1 ); 
	     // 通过put_next函数,将消息传递给下一个过滤器
	     put_next (mblk); 
	  }
       ACE_NEW_RETURN(mblk, ACE_Message_Block (0, ACE_Message_Block::MB_STOP),  0);
	   put_next (mblk);
	   fin.close();
	   ACE_DEBUG ((LM_DEBUG, "read svc return .\n")); 
       return 0;
    }
Example #10
0
/*****************************************************************************
 Function:    sendEsRtpPacket
 Description: 
 Input:       pRtpData  解析成ES流后的一包数据
              unDataSize ES流的一包数据的长度
 Output:      
 Return:      N/A
*****************************************************************************/
void CPs2EsProcessor::sendEsRtpPacket(const char* pRtpData, unsigned int unDataSize)
{
    //CHECK_POINTER_VOID(pRtpData);

    if (0 == unDataSize)
    {        
        //BP_RUN_LOG_ERR(IVS_FAIL, "Send Es rtp packet fail, data size invalid",            "size=%u, serviceID=%s.", unDataSize, m_strServiceID.c_str());
        return;
    }

    ACE_Message_Block *pRtpBlock = CMediaBlockBuffer::instance().allocMediaBlock();
    if (NULL == pRtpBlock)
    {
        //BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR, "Alloc media block fail.",            "serviceID=%s.", m_strServiceID.c_str());
        return;
    }
	NALU_HEADER naluheader = *(NALU_HEADER*)pRtpBlock->rd_ptr();
    pRtpBlock->reset();
    pRtpBlock->copy(pRtpData, unDataSize);

	ST_FRAME_DATA frameData;
	frameData.iFrameDataType = naluheader.TYPE;
	frameData.iStreamType = _PAY_LOAD_TYPE_H264;
	//m_Mutex.Lock();
	if(NULL != m_fDataCallBack)
	{
		m_fDataCallBack(m_pUser, pRtpBlock,&frameData);
	}
	//m_Mutex.UnLock();
    CMediaBlockBuffer::instance().freeMediaBlock(pRtpBlock);
    return;
}
Example #11
0
static void *
connector (void *)
{
  ACE_UPIPE_Stream c_stream;

  ACE_OS::sleep (5);

  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) connector starting connect\n")));
  ACE_UPIPE_Connector con;

  if (con.connect (c_stream, addr) == -1)
    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) connector ACE_UPIPE_Connector failed\n")));

  ACE_Message_Block *mb = 0;

  ACE_NEW_RETURN (mb, ACE_Message_Block (sizeof ("hello thanks") * sizeof (char)), 0);

  mb->copy ("hello");

  if (c_stream.send (mb) == -1)
    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) error connector send\n")));

  if (c_stream.recv (mb) == -1)
    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) error connector recv\n")));

  ACE_TEST_ASSERT (ACE_OS::strcmp (mb->rd_ptr (), "thanks") == 0);

  // Free up the memory block.
  mb->release ();

  // Now try the send()/recv() interface.
  char mytext[] = "This string is sent by connector as a buffer";

  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) connector sending text\n")));
  if (c_stream.send (mytext, sizeof (mytext)) == -1)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("(%t) buffer send from connector failed\n")));

  char conbuf[BUFSIZ];  // Buffer to receive response.

  int i = 0;

  for (char c = ' '; c != '!'; i++)
    {
      if (c_stream.recv (&c, 1) == -1)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("(%t) buffer recv from connector failed\n")));
      else
        conbuf[i] = c;
    }

  conbuf[i] = '\0';
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) conbuf = %s\n"), conbuf));
  ACE_TEST_ASSERT (ACE_OS::strcmp (conbuf, "this is the acceptor response!") == 0);

  c_stream.close ();
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) exiting thread\n")));
  return 0;
}
Example #12
0
static void *
peer2 (void *)
{
  ACE_UPIPE_Acceptor acc (addr);
  ACE_UPIPE_Stream s_stream;

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

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

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

  ACE_Message_Block *mb = 0;

  if (s_stream.recv (mb) == -1)
    ACE_ERROR ((LM_ERROR,
                "(%t) peer2 recv failed\n"));

  ACE_DEBUG ((LM_DEBUG, "(%t) peer2 recv is \"%s\"\n",
              mb->rd_ptr ()));

  mb->wr_ptr (mb->rd_ptr ());
  mb->copy ("thanks", 7);

  if (s_stream.send (mb) == -1)
    ACE_ERROR ((LM_ERROR,
                "(%t) peer2 send failed\n"));

  char s_buf[42];
  ACE_DEBUG ((LM_DEBUG,
              "(%t) peer2 sleeping on recv\n"));

  if (s_stream.recv (s_buf, sizeof s_buf) == -1)
    ACE_ERROR ((LM_ERROR,
                "(%t) peer2 recv failed\n"));
  else
    ACE_DEBUG ((LM_DEBUG,
                "(%t) peer2 received buffer with \"%s\"\n",
                s_buf));

  ACE_OS::strcpy (s_buf,
                  "this is the peer2 response!");

  if (s_stream.send (s_buf, 30) == -1)
    ACE_ERROR ((LM_ERROR,
                "(%t) peer2 send failed\n"));
  s_stream.close ();
  return 0;
}
Example #13
0
int PacketQueue::QueuePacket(FieldPacket* packet)
{
    ACE_Message_Block* mb;
    ACE_NEW_RETURN(mb, ACE_Message_Block(sizeof(packet)), -1);
    mb->copy((const char*)&packet, sizeof(packet));
    ACE_Time_Value tv;
    return this->enqueue(mb, &tv);
}
Example #14
0
// Called when input is available from the client
//
// We can handle requests until the peer closes on, potentially, many connections simultaneously.
// We do this asynchronously, acoiding blocking I/O operations which are bad because they block all connection processing. 
//
int ClientService::handle_input(ACE_HANDLE fileDescriptor)
{
	const size_t inputSize = 4096;
	char		 buffer[inputSize];
	ssize_t		 receivedBytes;
	ssize_t		 sentBytes;

	if ((receivedBytes = m_socket.recv(buffer, sizeof(buffer))) <= 0)
	{
		ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Connection closed\n")));
		return -1;
	}

	sentBytes = m_socket.send(buffer, static_cast<size_t>(receivedBytes));

	if (sentBytes == receivedBytes)
	{
		return 0;
	}

	if (sentBytes == -1 && ACE_OS::last_error() != EWOULDBLOCK)
	{
		ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) %p\n"), ACE_TEXT("send")), 0);
	}

	if (sentBytes == -1)
	{
		sentBytes = 0;
	}

	//
	ACE_Message_Block* message;

	size_t remaining = static_cast<size_t>(receivedBytes - sentBytes);

	ACE_NEW_RETURN(message, ACE_Message_Block(remaining), -1);

	message->copy(&buffer[sentBytes], remaining);

	bool isEmpty = m_queue.is_empty();

	ACE_Time_Value nowait(ACE_OS::gettimeofday());

	if (m_queue.enqueue_tail(message, &nowait) == -1)
	{
		ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) %p; discarding data\n"), ACE_TEXT("enqueue failed")));
		message->release();
		return 0;
	}

	if (isEmpty)
	{
		return this->reactor()->register_handler(this, ACE_Event_Handler::WRITE_MASK);		
	}

	return 0;
}
Example #15
0
void
HTTP_Client_Connection::on_open(ACE_Message_Block& mb)
{
	std::string request = "GET / HTTP/1.1\r\n" \
		"Host: localhost\r\n" \
		"\r\n";
	mb.copy(request.c_str(), request.size());

	this->write(mb);
}
// 直接传入拼装完成的内容部分,组成CMD,传递文件使用
CCmd* CNSSOperator::BuildCmd(const std::string& strLinkID, int iNetElementType, unsigned short iReqID, const char* pData, int length) const
{
	CCmd* pCmd = NULL;
	HW_NEW(pCmd, CCmd); //lint !e774
	CHECK_POINTER(pCmd, NULL);
	pCmd->SetNetElemType(iNetElementType); 
	pCmd->SetNetLinkID(strLinkID);
	pCmd->SetServiceID(SERVICE_COMMU);
	pCmd->SetReqID(iReqID);
	pCmd->SetCmdType(CMD_SEND);

	// 生成事务ID
	std::string strTransID = CMKTransID::Instance().GenerateTransID();
	pCmd->SetTransID(strTransID);
	// NSS头
	TNssMsgHeader m_header;
	memset(&m_header, 0, sizeof(TNssMsgHeader));
	m_header.usiProtocolVersion = 0x0100;
	m_header.usiMsgType = iReqID;
	m_header.uiSeqID = 0; 
	m_header.uiTraceID = 0;
	strncpy(m_header.szTransactionNo, strTransID.c_str(), MaxTransactionNoLength - 1);
	m_header.uiRspCode = 0;  
	m_header.uiPacketLength = sizeof(TNssMsgHeader) + static_cast<IVS_UINT32>(length);

	// 转换网络字节序
	m_header.usiProtocolVersion = ntohs(m_header.usiProtocolVersion);
	m_header.usiMsgType = ntohs(m_header.usiMsgType);
	m_header.uiSeqID = ntohl(m_header.uiSeqID);
	m_header.uiTraceID = ntohl(m_header.uiTraceID);
	m_header.uiRspCode = ntohl(m_header.uiRspCode);
	m_header.uiPacketLength = ntohl(m_header.uiPacketLength);
	
	// 定义ACE的消息缓冲,这个在cmd里面去释放,这里不释放
	ACE_Message_Block* pMsgBlock = new ACE_Message_Block(sizeof(TNssMsgHeader) + static_cast<IVS_UINT32>(length)); //lint !e429
	
	pMsgBlock->copy((char*)&m_header, sizeof(TNssMsgHeader));
	pMsgBlock->copy(pData, static_cast<IVS_UINT32>(length));

	// 设置数据到CMD,数据应该由CMD统一释放掉
	pCmd->SetMsgBlock(pMsgBlock);//lint !e613
	return pCmd;//lint !e429
}
Example #17
0
    virtual int  on_open () 
    {
        ACE_Message_Block * mb = this->alloc_msg ();
        if (mb == 0 )
        {
            return 0;
        }

        mb->copy (data );
        mb->reset ();
        mb->wr_ptr (cfg.s_blksize ());

        return this->start_write (*mb);
    }
Example #18
0
int
ACE_TMAIN (int /* argc */, ACE_TCHAR * /* argv */ [])
{
#if defined (ACE_HAS_MONITOR_FRAMEWORK) && (ACE_HAS_MONITOR_FRAMEWORK == 1)

  /// Create a message queue with a built-in monitor (since ACE was
  /// compiled with monitors enabled) and add the monitor to the
  /// registry (some ACE activities create a message queue under
  /// the hood, so we must make the registration explicit).
  ACE_Message_Queue<ACE_NULL_SYNCH> monitored_queue;

  /// The message string is 11 bytes long so the message queue will
  /// grow and shrink in 11-byte increments.
  ACE_Message_Block *mb = 0;
  const char *msg = "Hidely Ho!";

  /// Run the monitor checker in a separate thread.
  Monitor_Checker monitor_checker (&monitored_queue);
  monitor_checker.activate ();

  for (int i = 0; i < 10; ++i)
    {
      ACE_OS::sleep (1);

      /// Add 6 message blocks to the queue, then remove
      /// 4 of them.
      if (i < 6)
        {
          mb = new ACE_Message_Block (ACE_OS::strlen (msg) + 1);
          mb->copy (msg);
          monitored_queue.enqueue_tail (mb);
        }
      else
        {
          monitored_queue.dequeue_head (mb);
          mb->release ();
        }
    }

  /// This makes Purify much happier, but doesn't seem necessary for
  /// a regular run.
  monitor_checker.wait ();

  /// Clean up the remaining message queue resources.
  monitored_queue.flush ();

#endif /* ACE_HAS_MONITOR_FRAMEWORK==1 */

  return 0;
}
int DealerSvcHandler::enqueue_card_for_output(char s, char r) {
  buffer[0] = s;
  buffer[1] = r;
  ACE_Message_Block *mb;
  mb = new ACE_Message_Block(MSG_BLOCK_SIZE);
  mb->copy(buffer, MSG_BLOCK_SIZE);
  ACE_Time_Value tv(TIMEOUT_VALUE1);
  putq(mb, &tv);
  ACE_Reactor::instance ()->mask_ops(this,
				     ACE_Event_Handler::WRITE_MASK |
				     ACE_Event_Handler::READ_MASK,
				     ACE_Reactor::SET_MASK);
  return 0;
}
Example #20
0
 virtual int on_read_completed (AsynchChannel *channel,
                                const char    *data,
                                size_t         length)
 {
     ACE_Message_Block *mb = 
         channel->alloc_msg (sizeof(header) +
                             length +
                             sizeof(trailer));
     
     if (mb == 0)
     {
         return -1;
     }
     mb->copy (header);
     mb->copy (data);
     mb->copy (trailer);
     
     Job job(channel, mb);
     if (!this->get_job_pool().put (job))
     {
         return -1;
     }
     return length;
 }
Example #21
0
// Listing 5 code/ch07
int
ClientService::handle_input (ACE_HANDLE)
{
  const size_t INPUT_SIZE = 4096;
  char buffer[INPUT_SIZE];
  ssize_t recv_cnt, send_cnt;

  recv_cnt = this->peer ().recv (buffer, sizeof(buffer));
  if (recv_cnt <= 0)
    {
      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("(%P|%t) Connection closed\n")));
      return -1;
    }

  send_cnt =
    this->peer ().send (buffer,
                        static_cast<size_t> (recv_cnt));
  if (send_cnt == recv_cnt)
    return 0;
  if (send_cnt == -1 && ACE_OS::last_error () != EWOULDBLOCK)
    ACE_ERROR_RETURN ((LM_ERROR,
                       ACE_TEXT ("(%P|%t) %p\n"),
                       ACE_TEXT ("send")),
                      0);
  if (send_cnt == -1)
    send_cnt = 0;
  ACE_Message_Block *mb;
  size_t remaining =
    static_cast<size_t> ((recv_cnt - send_cnt));
  ACE_NEW_RETURN (mb, ACE_Message_Block (remaining), -1);
  mb->copy (&buffer[send_cnt], remaining);
  int output_off = this->msg_queue ()->is_empty ();
  ACE_Time_Value nowait (ACE_OS::gettimeofday ());
  if (this->putq (mb, &nowait) == -1)
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("(%P|%t) %p; discarding data\n"),
                  ACE_TEXT ("enqueue failed")));
      mb->release ();
      return 0;
    }
  if (output_off)
    return this->reactor ()->register_handler
      (this, ACE_Event_Handler::WRITE_MASK);
  return 0;
}
Example #22
0
    virtual int on_read_finished (ACE_Message_Block & mb,
                                  int error,
                                  int xfer_bytes)
    {
        if (error !=0 || xfer_bytes == 0)
        {
            return -1;
        }

        mb.reset ();

        mb.copy (data );
        mb.reset ();
        mb.wr_ptr (cfg.blksize());
        
        return this->start_write (mb);
    }
Example #23
0
void RASocket::zprint(void* callbackArg, const char * szText)
{
    if (!szText || !callbackArg)
        return;

    RASocket* socket = static_cast<RASocket*>(callbackArg);
    size_t sz = strlen(szText);

    ACE_Message_Block* mb = new ACE_Message_Block(sz);
    mb->copy(szText, sz);

    if (socket->putq(mb, const_cast<ACE_Time_Value*>(&ACE_Time_Value::zero)) == -1)
    {
        sLog->outRemote("Failed to enqueue message, queue is full or closed. Error is %s", ACE_OS::strerror(errno));
        mb->release();
    }
}
Example #24
0
void ProactorService::SendInternal(char* pBuffer, int bufferSize)
{			
	ACE_Message_Block* pBlock = NULL;

	ACE_NEW_NORETURN(pBlock, ACE_Message_Block(bufferSize));

	pBlock->copy((const char*)pBuffer, bufferSize);

	if(NULL == pBlock->cont())
	{
		m_AsyncWriter.write(*pBlock, pBlock->length());
	}
	else
	{
		m_AsyncWriter.writev(*pBlock, pBlock->total_length());
	}	
}
static void
run_test (SVC_HANDLER &svc_handler,
          size_t iterations)
{
  // Create a whole slew of message blocks and pass them to the
  // <svc_handler>.
  for (size_t i = 0; i < iterations; i++)
    {
      ACE_Message_Block *mb;
      ACE_NEW (mb,
               ACE_Message_Block (sizeof (ACE_LIB_TEXT("hello "))));

      ACE_Message_Block *cb1;
      ACE_NEW (cb1,
               ACE_Message_Block (sizeof (ACE_LIB_TEXT("there\n"))));

      ACE_Message_Block *cb2;
      ACE_NEW (cb2,
               ACE_Message_Block (sizeof (ACE_LIB_TEXT("there\n"))));

      mb->copy ("hello ",
                ACE_OS::strlen (ACE_LIB_TEXT("hello ")));
      cb1->copy ("there ",
                 ACE_OS::strlen (ACE_LIB_TEXT("there ")));
      mb->cont (cb1);
      cb2->copy ("doug\n",
                ACE_OS::strlen (ACE_LIB_TEXT("doug\n")));
      cb1->cont (cb2);

      // Note that this is a buffered call!
      if (svc_handler.put (mb) == -1)
        ACE_ERROR ((LM_ERROR,
                    ACE_TEXT ("%p\n"),
                    ACE_TEXT ("put")));
    }

  ACE_DEBUG ((LM_DEBUG,
              ACE_TEXT ("final flush\n")));

  // Make sure to flush everything out before we exit.
  if (svc_handler.flush () == -1)
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("%p\n"),
                ACE_TEXT ("flush")));
}
Example #26
0
void RASocket::zprint(void* callbackArg, const char * szText)
{
    if (!szText || !callbackArg)
        return;

    RASocket* socket = static_cast<RASocket*>(callbackArg);
    size_t sz = strlen(szText);

    ACE_Message_Block* mb = new ACE_Message_Block(sz);
    mb->copy(szText, sz);

    ACE_Time_Value tv = ACE_Time_Value::zero;
    if (socket->putq(mb, &tv) == -1)
    {
        TC_LOG_DEBUG(LOG_FILTER_REMOTECOMMAND, "Failed to enqueue message, queue is full or closed. Error is %s", ACE_OS::strerror(errno));
        mb->release();
    }
}
// Note: The FooDataWriter gives ownership of the marshalled data
//       to the WriteDataContainer.
ACE_Message_Block*
 FooDataWriterImpl::marshal(
                const Foo& instance_data,
                int  for_write)
{
  ACE_Message_Block* mb;
  if (for_write)
  {
    ACE_NEW_MALLOC_RETURN (mb,
                           static_cast<ACE_Message_Block*> (
                             mb_allocator_->malloc (
                             sizeof (ACE_Message_Block))),
                           ACE_Message_Block( sizeof (Foo),
                                              ACE_Message_Block::MB_DATA,
                                              0, //cont
                                              0, //data
                                              foo_allocator_, //allocator_strategy
                                              0, //locking_strategy
                                              ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY,
                                              ACE_Time_Value::zero,
                                              ACE_Time_Value::max_time,
                                              db_allocator_,
                                              mb_allocator_),
                            0);
    mb->copy ((const char *)&instance_data, sizeof (Foo));
  }
  else
  { // Don't use the cached allocator for the registered sample message
    // block.
    Foo* register_sample = new Foo();
    *register_sample = instance_data;

    ACE_NEW_RETURN (mb,
                    ACE_Message_Block ((const char*)register_sample,
                                        sizeof (Foo)),
                    0);
    // Let the PublicationInstance destructor release the Message Block
    // and delete this register_sample.
    mb->clr_flags(ACE_Message_Block::DONT_DELETE);
  }

  return mb;
}
Example #28
0
int
ACE_RMCast_Reassembly_Tester::compare (ACE_Message_Block *received,
                                       ACE_Message_Block *original)
{
  size_t n = original->total_size ();
  ACE_Message_Block blob (n);

  for (const ACE_Message_Block *i = original; i != 0; i = i->cont ())
    {
      blob.copy (i->rd_ptr (), i->length ());
    }

  if (received->rd_ptr () == 0)
    ACE_ERROR_RETURN ((LM_DEBUG, ACE_TEXT ("INCOMPLETE MESSAGE\n")), -1);

  if (ACE_OS::memcmp (blob.rd_ptr (),
                      received->rd_ptr (),
                      n) != 0)
    {
      for (size_t i = 0; i < n; i += 256)
        {
          size_t z = 256;
          if (n - i < 256)
            z = n - i;
          ACE_HEX_DUMP ((LM_DEBUG,
                         blob.rd_ptr () + i,
                         z,
                         ACE_TEXT ("BIG BLOB")));
        }
      for (size_t j = 0; j < n; j += 256)
        {
          size_t z = 256;
          if (n - j < 256)
            z = n - j;
          ACE_HEX_DUMP ((LM_DEBUG,
                         received->rd_ptr () + j,
                         z,
                         ACE_TEXT ("RECEIVED")));
        }
      return -1;
    }
  return 0;
}
Example #29
0
static void *
acceptor (void *args)
{
  ACE_UPIPE_Acceptor *acceptor = (ACE_UPIPE_Acceptor *) args;
  ACE_UPIPE_Stream s_stream;

  if (acceptor->accept (s_stream) == -1)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("(%t) ACE_UPIPE_Acceptor.accept failed\n")));

  ACE_Message_Block *mb = 0;

  if (s_stream.recv (mb) == -1)
    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) acceptor recv failed\n")));

  ACE_TEST_ASSERT (ACE_OS::strcmp (mb->rd_ptr (), "hello") == 0);

  mb->wr_ptr (mb->rd_ptr ());
  mb->copy ("thanks");

  if (s_stream.send (mb) == -1)
    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) acceptor send failed\n")));

  char s_buf[BUFSIZ];
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) acceptor sleeping on recv\n")));

  if (s_stream.recv (s_buf, sizeof (s_buf)) == -1)
    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) acceptor recv failed\n")));
  else
    ACE_TEST_ASSERT (ACE_OS::strcmp (s_buf,
                                "This string is sent by connector as a buffer") == 0);

  const char svr_response[] = "this is the acceptor response!";
  ACE_OS::strcpy (s_buf, svr_response);

  if (s_stream.send (s_buf, sizeof (svr_response)) == -1)
    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) acceptor send failed\n")));

  s_stream.close ();
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) exiting thread\n")));
  return 0;
}
Example #30
0
ACE_Message_Block *
Text_Input_Device_Wrapper::create_input_message (void)
{

  // Construct a new message block to send.
  ACE_Message_Block *mb = 0;
  ACE_NEW_RETURN (mb,
                  ACE_Message_Block (read_length_),
                  0);

  // Zero out a "read" buffer to hold data.
  char read_buf [BUFSIZ];
  ACE_OS::memset (read_buf, 0, BUFSIZ);

  // Loop through the text, filling in data to copy into the read
  // buffer (leaving room for a terminating zero).
  for (size_t i = 0; i < read_length_ - 1; ++i)
    {
      read_buf [i] = text_ [index_];
      index_ = (index_ + 1) % ACE_OS::strlen (text_);
    }

  // Copy buf into the Message_Block and update the wr_ptr ().
  if (mb->copy (read_buf, read_length_) < 0)
    {
      delete mb;
      ACE_ERROR_RETURN ((LM_ERROR,
                         "read buffer copy failed"),
                        0);
    }

  // log packet creation if logging is turned on
  if (logging_ & Text_Input_Device_Wrapper::LOG_MSGS_CREATED)
    {
      ++packet_count_;
      ACE_DEBUG ((LM_DEBUG, "input message %d created\n",
                  packet_count_));
    }

  return mb;
}