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; }
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; }
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; }
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; }
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); }
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; }
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; }
/***************************************************************************** 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; }
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; }
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; }
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); }
// 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; }
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 }
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); }
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; }
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; }
// 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; }
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); }
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(); } }
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"))); }
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; }
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; }
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; }
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; }