bool DummyStorageLink::onDown(const api::StorageMessage::SP& cmd)
{
if (_ignore) {
return false;
}
if (_injected.size() > 0) {
vespalib::LockGuard guard(_lock);
sendUp(*_injected.begin());
_injected.pop_front();
} else if (_autoReply) {
if (!cmd->getType().isReply()) {
std::shared_ptr<api::StorageReply> reply(
std::dynamic_pointer_cast<api::StorageCommand>(cmd)
->makeReply().release());
reply->setResult(api::ReturnCode(
api::ReturnCode::OK, "Automatically generated reply"));
sendUp(reply);
}
}
if (isBottom()) {
vespalib::MonitorGuard lock(_waitMonitor);
{
vespalib::LockGuard guard(_lock);
_commands.push_back(cmd);
}
lock.broadcast();
return true;
}
return StorageLink::onDown(cmd);
}
void CsmaAloha::stateRxData(Packet* data_pkt) {
refreshState( CSMA_STATE_DATA_RX );
if (debug_) cout << NOW << " CsmaAloha("<< addr << ")::stateRxData() in state " << status_info[curr_state] << endl;
refreshReason( CSMA_REASON_DATA_RX );
hdr_mac* mach = HDR_MAC(data_pkt);
int dst_addr = mach->macSA();
switch( prev_state ) {
case CSMA_STATE_RX_IDLE: {
hdr_cmn* ch = hdr_cmn::access(data_pkt);
ch->size() = ch->size() - HDR_size;
incrDataPktsRx();
sendUp(data_pkt);
if (ack_mode == CSMA_ACK_MODE) stateTxAck(dst_addr);
else stateIdle();
}
break;
case CSMA_STATE_RX_LISTEN: {
hdr_cmn* ch = hdr_cmn::access(data_pkt);
ch->size() = ch->size() - HDR_size;
incrDataPktsRx();
sendUp(data_pkt);
if (ack_mode == CSMA_ACK_MODE) stateTxAck(dst_addr);
else stateCheckListenExpired();
}
break;
case CSMA_STATE_RX_BACKOFF: {
hdr_cmn* ch = hdr_cmn::access(data_pkt);
ch->size() = ch->size() - HDR_size;
incrDataPktsRx();
sendUp(data_pkt);
if (ack_mode == CSMA_ACK_MODE) stateTxAck(dst_addr);
else stateCheckBackoffExpired();
}
break;
default:
cerr << NOW << " CsmaAloha("<< addr << ")::stateRxData() logical error, prev state = " << status_info[prev_state]
<< endl;
}
}
LONGBOW_TEST_CASE(Dictionary, component_Codec_Tlv_Upcall_Read_Control)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
PARCBuffer *wireFormat = parcBuffer_Wrap(v1_cpi_add_route_crc32c, sizeof(v1_cpi_add_route_crc32c),
0, sizeof(v1_cpi_add_route_crc32c));
CCNxTlvDictionary *dictionary = ccnxWireFormatMessage_FromControlPacketType(CCNxTlvDictionary_SchemaVersion_V1, wireFormat);
parcBuffer_Release(&wireFormat);
// We have not set the message type or schema
TransportMessage *tm = transportMessage_CreateFromDictionary(dictionary);
transportMessage_SetInfo(tm, data->mock->connection, NULL);
ccnxTlvDictionary_Release(&dictionary);
// ------
// Now do the actual test of sending the transport message up the stack
TransportMessage *test_tm = sendUp(data, tm);
// It should now be parsed into an control message
CCNxTlvDictionary *testdict = transportMessage_GetDictionary(test_tm);
assertNotNull(testdict, "Failed to get dictionary from the transport message");
assertTrue(ccnxTlvDictionary_IsControl(testdict), "Dictionary says it is not a Control");
assertTrue(ccnxTlvDictionary_GetSchemaVersion(testdict) == CCNxTlvDictionary_SchemaVersion_V1,
"Wrong schema, got %d expected %d",
ccnxTlvDictionary_GetSchemaVersion(testdict), CCNxTlvDictionary_SchemaVersion_V1);
transportMessage_Destroy(&tm);
}
void
UwCsmaAloha_Trigger_SINK::stateRxData(Packet *data_pkt)
{
refreshState(UW_CS_ALOHA_TRIG_SINK_STATE_DATA_RX);
if (debug_)
cout << NOW << " UwCsmaAloha_Trigger_SINK(" << addr
<< ")::stateRxData() " << endl;
incrDataPktsRx();
sendUp(data_pkt);
}
void
UWMllModule::recv(Packet *p, int idSrc)
{
hdr_cmn *ch = HDR_CMN(p);
if (ch->direction() == hdr_cmn::UP) {
sendUp(p);
} else {
ch->direction() = hdr_cmn::DOWN;
sendDown(p);
}
}
void BlueCoreDeviceController_newStyle::Implementation::checkQueues ()
{
PDU pdu(null_pdu);
for ( int i = 0 ; i < PDU::csr_hci_extensions_count ; ++i )
{
for ( int j = 0 ; j < 8 && pending[i]->getNextIfAvailable(pdu) ; ++j )
{
mConnectionToChip->sendpdu ( pdu );
if (pdu.channel() == PDU::hciACL)
aclDataTracker.removeData(pdu);
}
}
// deal with packets coming up...
for ( int j = 0 ; j < 8 && upstream.get( pdu ) ; ++j )
{
PDU::bc_channel ch = pdu.channel();
switch ( ch )
{
case PDU::bccmd:
pending[PDU::bccmd]->setToken();
break;
case PDU::hq :
{
if ( HQ_PDU(pdu).get_req_type() == HQPDU_SETREQ )
{
HQ_PDU ret ( pdu.clone () );
ret.set_req_type ( HQPDU_GETRESP );
pending[PDU::hq]->add(sae(ret,no_call_back));
}
break;
}
case PDU::hciCommand:
{
HCIEventPDU ev ( pdu );
switch ( ev.get_event_code() )
{
case HCI_EV_NUMBER_COMPLETED_PKTS:
{
HCI_EV_NUMBER_COMPLETED_PKTS_T_PDU ncp( pdu );
uint8 count = ncp.get_num_handles();
for ( uint8 i = 0 ; i < count ; ++i )
{
uint16 handle;
uint16 tokens;
ncp.get_num_completed_pkts(i,handle,tokens);
pending[PDU::hciACL]->incToken(tokens);
}
}
break;
case HCI_EV_COMMAND_COMPLETE:
{
HCICommandCompletePDU cc (pdu);
pending[PDU::hciCommand]->setToken(cc.get_num_hci_command_pkts() );
switch(cc.get_op_code())
{
case HCI_READ_VOICE_SETTING:
{
HCI_READ_VOICE_SETTING_RET_T_PDU rvs(pdu);
if ( rvs.get_status() == HCI_SUCCESS )
{
bool is_it_16 = (rvs.get_voice_setting()
& HCI_VOICE_SAMP_SIZE_MASK)
== HCI_VOICE_SAMP_SIZE_16BIT;
scoBandwidthTracker.set_audio_sample_size ( is_it_16 ? 16 : 8 );
}
}
break;
case HCI_READ_BUFFER_SIZE:
if ( !initialised_ACL_flow_control )
{
HCI_READ_BUFFER_SIZE_RET_T_PDU rbs ( pdu );
if ( rbs.get_status() == HCI_SUCCESS )
{
initialised_ACL_flow_control = true;
pending[PDU::hciACL]->setToken ( rbs.get_total_acl_data_pkts() );
}
}
break;
}
}
break;
case HCI_EV_COMMAND_STATUS:
{
HCI_EV_COMMAND_STATUS_T_PDU cc (pdu);
pending[PDU::hciCommand]->setToken(cc.get_num_hci_command_pkts() );
if (cc.get_op_code() == HCI_ADD_SCO_CONNECTION
&& cc.get_status() != HCI_COMMAND_CURRENTLY_PENDING )
{
getTransport()->set_sco_bandwidth(scoBandwidthTracker.decrease());
}
}
break;
case HCI_EV_CONN_COMPLETE:
{
HCI_EV_CONN_COMPLETE_T_PDU cc(pdu);
if (cc.get_status() == HCI_SUCCESS)
{
if (cc.get_link_type() == HCI_LINK_TYPE_ACL)
aclDataTracker.addConnection(cc.get_handle());
else
{
// sco or esco. This will glitch if we were the initiating end.
getTransport()->set_sco_bandwidth(scoBandwidthTracker.consolidate(cc.get_handle()));
}
}
else
{
if (cc.get_link_type() == HCI_LINK_TYPE_SCO)
{
getTransport()->set_sco_bandwidth(scoBandwidthTracker.decrease());
}
}
}
break;
case HCI_EV_DISCONNECT_COMPLETE:
{
HCI_EV_DISCONNECT_COMPLETE_T_PDU dc(pdu);
if ( dc.get_status() == HCI_SUCCESS )
{
uint16 h = dc.get_handle();
if (aclDataTracker.usingConnection(h))
aclDataTracker.removeConnection(h);
else
{
// sco or esco
getTransport()->set_sco_bandwidth(scoBandwidthTracker.decrease(h));
}
}
}
break;
case HCI_EV_SYNC_CONN_COMPLETE:
{
HCI_EV_SYNC_CONN_COMPLETE_T_PDU scc(pdu);
if ( scc.get_status() == HCI_SUCCESS )
{
// sco or esco. This will glitch if we were the initiating end.
getTransport()->set_sco_bandwidth(scoBandwidthTracker.consolidate(scc.get_handle()));
}
else
scoBandwidthTracker.decrease();
}
break;
case HCI_EV_LOOPBACK_COMMAND:
// we just had a command loop back, so allow us to send another.
pending[PDU::hciCommand]->setToken(1);
break;
default:
break;
}
break;
}
default:
break;
}
if ( !pending[ch]->run_callback(pdu) )
mReceiver.onPDU ( pdu );
// some stuff should be passed up... HQ and HCI only?
if ( mConnectionOnOffer )
{
switch ( ch )
{
case PDU::hq:
case PDU::hciCommand:
case PDU::hciACL:
case PDU::hciSCO:
(void)sendUp ( pdu );
break;
default:
// do nothing
break;
}
}
}
// accept requests from higher layers on all channels.
for ( int k = 0 ; k < 8 && downstream.get( pdu ) ; ++k )
{
switch ( pdu.channel() )
{
case PDU::hciCommand:
case PDU::hciACL:
case PDU::hciSCO:
(void)send ( sae ( pdu , perm_no_pass ) , true );
break;
default:
(void)send ( sae ( pdu , perm_pass_up ) , true );
break;
}
}
}
