CmResult COFP13MPAggregateFlowStatsRequestMsg:: StreamTo(ACE_OutputCDR &os) { if (COFP13MultipartMsg::StreamTo(os) != CM_OK) { return CM_ERROR_FAILURE; } os<<m_stats_request.table_id; os.write_octet_array(m_stats_request.pad, sizeof(m_stats_request.pad)); os<<m_stats_request.out_port; os<<m_stats_request.out_group; os.write_octet_array(m_stats_request.pad2, sizeof(m_stats_request.pad2)); os<<m_stats_request.cookie; os<<m_stats_request.cookie_mask; bool bGood = os.good_bit(); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); return m_match.StreamTo(os); }
CmResult COFP10PacketOutMsg::StreamTo(ACE_OutputCDR &os) { CmResult lRet = CM_ERROR_FAILURE; lRet = COFPMessage::StreamTo(os); if (CM_FAILED(lRet)) { ACE_ERROR((LM_ERROR, ACE_TEXT("COFP10PacketOutMsg::StreamTo, COFPMessage::StreamTo fail\n"))); return lRet; } os<<m_tMember.buffer_id; os<<m_tMember.in_port; os<<m_tMember.actions_len; bool bGood = os.good_bit(); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); std::list<COFP10Action *>::const_iterator it = m_action_list.begin(); while (it != m_action_list.end()) { lRet = (*it)->StreamTo(os); CM_ASSERT_RETURN(CM_SUCCEEDED(lRet), CM_ERROR_FAILURE); it++; } if (m_PacketData) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("COFP10PacketOutMsg::StreamTo, m_PacketData->total_length() = %u\n"), m_PacketData->total_length())); std::string str = m_PacketData->flatten_chained(); os.write_char_array(str.c_str(), str.length()); } bGood = os.good_bit(); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); return CM_OK; }
// // operator << // bool operator << (ACE_OutputCDR & out, const ::OASIS::PointImpl & s) { if (!(out << s.x)) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%T (%t) - %M - failed to package x\n")), false); if (!(out << s.y)) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%T (%t) - %M - failed to package y\n")), false); return out.good_bit (); }
// send the test header (only contains number of iterations) int sendHeader(ACE_SOCK_Stream & stream) { // create an ACE CDR output stream and place the header information // into it ACE_OutputCDR hdrCDR; hdrCDR << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER); hdrCDR << ACE_CDR::ULong(Options_Manager::test_iterations+primerIterations); if (!hdrCDR.good_bit()) return (0); // send the header to the server (HEADER IS 8 BYTES LONG) size_t bt; if (stream.send_n(hdrCDR.begin(), 0, &bt) == -1) return 0; return 1; }
CmResult COFPSwitchConfig::StreamTo(ACE_OutputCDR &os) { CmResult lRet = CM_ERROR_FAILURE; lRet = COFPMessage::StreamTo(os); if (CM_FAILED(lRet)) { ACE_ERROR((LM_ERROR, ACE_TEXT("COFPSwitchConfig::StreamTo, COFPMessage::StreamTo fail\n"))); return lRet; } os<<m_wFlags; os<<m_wMissSendLen; bool bGood = os.good_bit(); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); return CM_OK; }
CmResult COFP13MPAggregateFlowStatsReplyMsg:: StreamTo(ACE_OutputCDR &os) { if (COFP13MultipartMsg::StreamTo(os) != CM_OK) { return CM_ERROR_FAILURE; } os<<m_flowstats.packet_count; os<<m_flowstats.byte_count; os<<m_flowstats.flow_count; os.write_octet_array(m_flowstats.pad, sizeof(m_flowstats.pad)); bool bGood = os.good_bit(); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); return CM_OK; }
int operator<< (ACE_OutputCDR &cdr, const ACE_Log_Record &log_record) { // The written message length can't be more than 32 bits (ACE_CDR::ULong) // so reduce it here if needed. ACE_CDR::ULong u_msglen = ACE_Utils::truncate_cast<ACE_CDR::ULong> (log_record.msg_data_len ()); // Insert each field from <log_record> into the output CDR stream. cdr << ACE_CDR::Long (log_record.type ()); cdr << ACE_CDR::Long (log_record.pid ()); cdr << ACE_CDR::LongLong (log_record.time_stamp ().sec ()); cdr << ACE_CDR::Long (log_record.time_stamp ().usec ()); cdr << u_msglen; #if defined (ACE_USES_WCHAR) cdr.write_wchar_array (log_record.msg_data (), u_msglen); #else cdr.write_char_array (log_record.msg_data (), u_msglen); #endif /* ACE_USES_WCHAR */ return cdr.good_bit (); }
int DataWrapper::write(const ACE_OutputCDR& cdr) { //This method writes to an ace socket stream. First, it will collect //the appropriate header which includes the message length. It will then //combine ACE blocks that hold the header and message, and send it. //If preparing the block or sending fails, it returns an appropriate error. //If the actual socket send fails, the connection will be closed (not sure what //else to do, since it shouldn't fail under a good connection) if(!cdr.good_bit()) ACE_ERROR_RETURN((LM_ERROR, "%s, %p\n",toString(theAddress).c_str(),"Failed while sending CDR"), -1); ACE_OutputCDR aceHead(headerLength); //Put header info into a CDR if(!(aceHead << (ACE_CDR::ULong)bitsForward) || !(aceHead << (ACE_CDR::ULong)cdr.length())) ACE_ERROR_RETURN( (LM_ERROR, "%s, %p\n",toString(theAddress).c_str(),"Failed while sending, CDR header"), -1 ); //Create a block with the header and message const_cast<ACE_Message_Block*>(aceHead.begin())->cont(const_cast<ACE_Message_Block*>(cdr.begin())); const ssize_t msgLength = headerLength + ACE_CDR::total_length(cdr.begin(), cdr.end()); // cout << toString(theAddress) << endl; //Send the message const ssize_t bytesSent = theStream.send_n(aceHead.begin()); // Clear the block const_cast<ACE_Message_Block*>(aceHead.begin())->cont(NULL); //Check whether the send succeeded (sent all the bytes). If not, we assume the socket has disconnected. // cout << "Bytes sent: " << bytesSent << " | msgLength: " << msgLength << endl; if( bytesSent != msgLength ) { theStream.close_writer(); ACE_ERROR_RETURN((LM_ERROR, "%s - %p\n",toString(theAddress).c_str(),"Socket failed while sending"), -1); } //Everything sent successfully return 0; }
CmResult COFP13PacketOutMsg::StreamTo(ACE_OutputCDR &os) { CmResult lRet = CM_ERROR_FAILURE; ACE_CDR::Octet pad[6]; lRet = COFPMessage::StreamTo(os); if (CM_FAILED(lRet)) { ACE_ERROR((LM_ERROR, ACE_TEXT("COFP13PacketOutMsg::StreamTo, COFPMessage::StreamTo fail\n"))); return lRet; } ACE_DEBUG((LM_DEBUG, ACE_TEXT("COFP13PacketOutMsg::StreamTo():\n"))); ACE_DEBUG((LM_DEBUG, ACE_TEXT("msgLen=%u\n"), GetMessageLength())); os<<m_buffer_id; os<<m_in_port; os<<m_actions_len; os.write_octet_array(pad, sizeof(pad)); bool bGood = os.good_bit(); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); ACE_DEBUG((LM_DEBUG, ACE_TEXT("m_actions_len=%u\n"), m_actions_len)); #if 0 while(!m_action_list.empty()) { CCmComAutoPtr<COpenFlowProtAction> action; action = m_action_list.front(); m_action_list.pop_front(); action->EncodeAction(os); } #endif ACE_UINT16 i = 0; std::list<COFP13Action *>::const_iterator it = m_action_list.begin(); while(it != m_action_list.end()) { lRet = (*it)->StreamTo(os); CM_ASSERT_RETURN(CM_SUCCEEDED(lRet), CM_ERROR_FAILURE); ACE_DEBUG((LM_DEBUG, ACE_TEXT("action[%u]'s length=%u\n"), i++, (*it)->GetActionLen())); bGood = os.good_bit(); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); it++; } // just for debugging ACE_UINT32 length = sizeof(m_buffer_id)+sizeof(m_in_port)+sizeof(m_actions_len)+sizeof(m_pad); ACE_DEBUG((LM_DEBUG, ACE_TEXT("length=%u\n"), length)); ACE_INT32 dataLen = GetStreamLen()-COFPMessage::GetStreamLen()-length-m_actions_len; ACE_DEBUG((LM_DEBUG, ACE_TEXT("dataLen=%d\n"), dataLen)); if (m_PacketData) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("m_PacketData->total_length() = %u\n"), m_PacketData->total_length())); std::string str = m_PacketData->flatten_chained(); bGood = os.write_char_array(str.c_str(), str.length()); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); } return CM_OK; }
// Logic of StreamTo is similar to StreamFrom. CmResult COFP13HelloMsg::StreamTo(ACE_OutputCDR &os) { bool bGood = false; ACE_UINT16 i = 0; CmResult lRet = CM_ERROR_FAILURE; lRet = COFPMessage::StreamTo(os); if (CM_FAILED(lRet)) { ACE_ERROR((LM_ERROR, ACE_TEXT("COFP13HelloMsg::StreamTo, COFPMessage::StreamTo fail\n"))); return lRet; } if (m_wLength < COFPMessage::GetStreamLen()) { ACE_ERROR((LM_ERROR, ACE_TEXT("COFP13HelloMsg::StreamTo(): m_wLength(%u) is less than OFP_MESSAGE_HDR_SIZE(%u).\n"), m_wLength, COFPMessage::GetStreamLen())); return CM_ERROR_FAILURE; } ACE_UINT16 data_size = m_wElemListLen; //m_wLength-OPENFLOW_MESSAGE_HDR_SIZE; ACE_UINT16 iter_size = 0; const ACE_CDR::Octet *pElem = m_pElemList; while (iter_size < m_wElemListLen) { ACE_UINT16 elem_type = GetHelloElemType(pElem); ACE_UINT16 elem_size = GetHelloElemLen(pElem); // elem size, excluding paddings os<<elem_type; os<<elem_size; bGood = os.good_bit(); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); ACE_DEBUG((LM_DEBUG, ACE_TEXT("COFP13HelloMsg::StreamTo(): encode hello elem %u\n"), i++)); ACE_DEBUG((LM_DEBUG, ACE_TEXT("elem_type=%u, elem_size=%u\n"), elem_type, elem_size)); if (elem_size < 4) { ACE_ERROR((LM_ERROR, ACE_TEXT("COFP13HelloMsg::StreamTo(): elem_size(%u) error, less than 4."), elem_size)); return CM_ERROR_FAILURE; } if ((elem_size + 7)/8*8 > data_size) { ACE_ERROR((LM_ERROR, ACE_TEXT("COFP13HelloMsg::StreamTo(): (elem_size + 7)/8*8=%u, greater than data_size(%u)\n"), (elem_size + 7)/8*8, data_size)); return CM_ERROR_FAILURE; } if (elem_type != OFPHET_VERSIONBITMAP) { ACE_ERROR((LM_ERROR, ACE_TEXT("COFP13HelloMsg::StreamTo(): elem_type(%u) isnot OFPHET_VERSIONBITMAP(%u).\n"), elem_type, OFPHET_VERSIONBITMAP)); return CM_ERROR_FAILURE; } ACE_UINT16 bitmap_size = elem_size-4; CM_ASSERT_RETURN((bitmap_size/4*4 == bitmap_size), CM_ERROR_INVALID_ARG); ACE_UINT16 iter_bitmap_size = 0; ACE_UINT16 bitmap_index = 0; while (iter_bitmap_size < bitmap_size)//(bitmap_size > 0) { ACE_UINT32 bitmap = GetVerBMHelloElemBitmap(pElem, bitmap_index); os<<bitmap; bGood = os.good_bit(); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); ACE_DEBUG((LM_DEBUG, ACE_TEXT("COFP13HelloMsg::StreamTo, bitmap[%u]=%u\n"), bitmap_index++, bitmap)); //bitmap_size -= sizeof(bitmap); iter_bitmap_size += sizeof(bitmap); } // deal with paddings ACE_UINT16 pad_length = (elem_size + 7)/8*8 - elem_size; bGood = os.write_octet_array(pElem + 4 + sizeof(ACE_UINT32) * bitmap_index, pad_length); CM_ASSERT_RETURN(bGood, CM_ERROR_FAILURE); iter_size += (elem_size + pad_length); data_size -= (elem_size + pad_length); pElem += (elem_size + pad_length); } return CM_OK; }