bool CTun::Init(unsigned p_uHexLimit, const char* p_szTunName)
{
m_uHexLimit = p_uHexLimit;
strncpy(m_szTunName, p_szTunName, sizeof m_szTunName-1);
m_szTunName[sizeof m_szTunName-1]=0;
// open interface
if ((m_nTunHandle = open(TUN_INTERFACE, O_RDWR)) < 0)
{
PERR("CTun::Init, open "TUN_INTERFACE);
return false;
}
NLOG_DBG ("CTun::Init, open "TUN_INTERFACE);
// set some parameters
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
strncpy(ifr.ifr_name, m_szTunName, IFNAMSIZ);
if (ioctl(m_nTunHandle, TUNSETIFF, (void *) &ifr) < 0)
{
if (errno == EBADFD)
{
PERR("CTun::Init, ioctl "TUN_INTERFACE", %s", m_szTunName);
return false;
}
}
//ioctl (m_nTunHandle, TUNSETNOCSUM, 1); // this sets NOCKSUM ("We don't need checksums calculated for packets coming in this device: trust us!")
NLOG_DBG ("CTun::Init, ioctl "TUN_INTERFACE", %s", m_szTunName);
return true;
}
void CRplNodeRsp::ProcessPublish()
{
IEPDBMngtBase::DBPublish dbPubl;
memcpy(dbPubl.sourceID, m_rDevMsg->m_oDstAddr.GetIPv6() + 8, sizeof(dbPubl.sourceID));
if (!MsgDataToXML(dbPubl.parsedMsg, false))
{ return;
}
NLOG_DBG("[RplNodeRsp::ProcessPublish]: XML publish: %s", dbPubl.parsedMsg.c_str());
if (!m_rDBMngt.SaveNodePublish(m_rDevMsg->MsgType(), dbPubl, m_rDevMsg))
{
NLOG_ERR("[RplNodeRsp::ProcessPublish]: failed to save msg from %s",
BuffToHEXStr(dbPubl.sourceID, sizeof(dbPubl.sourceID)).c_str());
return;
}
if (m_rDevMsg->MsgType() == UdpEventNodeRegistration)
{
NLOG_INFO("[RplNodeRsp::ProcessPublish]: Sending ACK for UdpEventNodeRegistration");
//build message
unsigned int size = sizeof(struct QueryHdr);
unsigned char msg[size];
memset(msg,0,size);
//hdr
SetQueryHdr(msg, UdpQueryAck, 2, m_rDevMsg->SequenceNum());
TDeviceMsg *pDevMsg = new TDeviceMsg(m_rDevMsg->m_oDstAddr, msg, size, m_rDevMsg->SequenceNum(), false);
m_rWriteQueue->Push(TDeviceMsg::Ptr(pDevMsg));
}
}
bool CTun::CollectPacket(IpPacket* p_poPacket)
{
if (!checkRead(10000))
{
return false;
}
ssize_t br = read(m_nTunHandle, p_poPacket, MAX_IP_PACKET_SIZE);
if(br < 0)
{
PERR("CTun::CollectPacket, read "TUN_INTERFACE);
return false;
}
NLOG_DBG("CollectPacket, if:%s, sz:%d, data[%s%s]", m_szTunName, br,
GET_HEX_LIMITED(&p_poPacket, (size_t)br, m_uHexLimit));
if (br < 1)
{
NLOG_WARN("CTun::CollectPacket, IP header too small: expected(1), received(0)");
return false;
}
int nIPversion = p_poPacket->Version();
switch(nIPversion){
case 4:
return collectIp4Packet(&p_poPacket->m_stIp4, br);
case 6:
return collectIp6Packet(&p_poPacket->m_stIp6, br);
default:
return false;
}
}
///////////////////////////////////////////////////////////////////////////////
///@author Costin Grigorescu
///@brief Forward DAO to EntryPoint
///@param [in] p_nDataFieldDescriptor - Data field descriptor
///@param [in] p_pPayload - DAO message
///@param [in] p_nPayloadLength - DAO message len
///@retval 0 - failed to send
///@retval 1 - success
///////////////////////////////////////////////////////////////////////////////
void CRplRootApp::AddDAORelayEncap(MgmtProtocol::CMgmtPMessage::MsgDAORelayData::DataFieldDescriptorType p_nDataFieldDescriptor,
const uint8_t* p_pPayload,
uint16_t p_nPayloadLength){
MgmtProtocol::CMgmtPMessage::Ptr pMsg(new MgmtProtocol::CMgmtPMessage);
//init header
pMsg->m_Header.SetMsgType(MgmtProtocol::CMgmtPMessage::DAO_RELAY);
pMsg->m_Header.m_u32SeqNo = m_pMgmtClientLink->m_oSeqNoGenerator.GetNextMsgId ( );
MgmtProtocol::CMgmtPMessage::MsgDAORelayData oMsgDAORelayData;
// set far id
oMsgDAORelayData.m_pu8_FAR_ID = GetFarId();
// set data field descriptor
oMsgDAORelayData.m_u8_DataFieldDescriptor = p_nDataFieldDescriptor;
// set DIO MOP
oMsgDAORelayData.m_u8_DIO_MOP = GET_MOP( &g_oRplInstance.m_oRplConfig );
// set lifetime_unit
oMsgDAORelayData.m_u16_DIOLifetimeUnit = m_stCfg.m_oMapConfig.m_oRplProfile.m_nDefRouteLifetimeUnit;
// set DAO message
oMsgDAORelayData.m_pu8_DAOData = p_pPayload;
oMsgDAORelayData.m_u32_DAODataLen = p_nPayloadLength;
NLOG_INFO( "Encap+ DAO_RELAY: far=%s, dfd=%d, dao_len=%d",
GetHex( oMsgDAORelayData.m_pu8_FAR_ID, oMsgDAORelayData.m_st_u8_FAR_ID_Len ),
oMsgDAORelayData.m_u8_DataFieldDescriptor,
oMsgDAORelayData.m_u32_DAODataLen );
NLOG_DBG( "\tdao=%s", GetHex( oMsgDAORelayData.m_pu8_DAOData, oMsgDAORelayData.m_u32_DAODataLen ) );
pMsg->SetData(&oMsgDAORelayData);
m_shpoCnsDaoMsg->OptionAddEncap(pMsg.get());
}
MgmtProtocol::DeviceType CRplRootApp::DeviceType4EToDeviceTypeMgmtP ( CMapShortAddrMgr::DeviceType4E p_pDeviceType4E, const TIpv6Addr *p_poIPv6Addr )
{
switch ( p_pDeviceType4E )
{
case CMapShortAddrMgr::DevType_TrIfUp:
return MgmtProtocol::TYPE_RplLocalEndpointIfUp;
case CMapShortAddrMgr::DevType_TrIfDown:
return MgmtProtocol::TYPE_RplLocalEndpointIfDown;
case CMapShortAddrMgr::DevType_EpOnBatt:
return MgmtProtocol::TYPE_RplEndpointOnBattery;
default:
break;
}
FILE *tmp = fopen("/opt/iprf/activity_files/tranceivers.txt", "r");
if (tmp)
{
char ip[255] = {0};
const char* address = FormatIPv6(p_poIPv6Addr);
while (fgets( ip, sizeof(ip),tmp) != NULL)
{
if (strstr(ip, address) != NULL)
{
if (strstr(ip, "IfUp") != NULL)
{
NLOG_DBG("Transceiver found : %s matches radio IP of %s setting type to 8!!!", ip, address);
fclose (tmp);
return MgmtProtocol::TYPE_RplLocalEndpointIfUp;
}
else
{
NLOG_DBG("Transceiver found : %s matches radio IP of %s setting type to 9!!!", ip, address);
fclose (tmp);
return MgmtProtocol::TYPE_RplLocalEndpointIfDown;
}
}
}
fclose (tmp);
NLOG_DBG("Didn't find endpoint %s in transceiver list.", address);
}
#ifdef MED_SIM
return MgmtProtocol::TYPE_RplSimEndpoint;
#else
return MgmtProtocol::TYPE_EndPointRPL;
#endif
}
void CRplRootApp::registerToNMS( )
{
if ( !g_pApp->m_stCfg.m_nUseUplinkIpv6ForFar ||
g_pApp->m_stCfg.m_nBHManagerEnabled )
{
return;
}
const TIpv6Prefix& farAddr = GetFarAddress( );
//1) register far with parent nms
uint8_t nmsId[IPv6_HOST_ID_LEN];
memset( nmsId, 0, IPv6_HOST_ID_LEN );
nmsId[IPv6_HOST_ID_LEN - 1] = 1;
nmsId[IPv6_HOST_ID_LEN - 5] = 1;
NLOG_DBG( "Registering far, addr=%s as child of nms, id=%s",
FormatIPv6Prefix( farAddr.m_oIPv6Addr.m_pucBytes, PrefixLenInBytes( farAddr.m_u8PrefixLen ) ),
FormatHex( nmsId, IPv6_HOST_ID_LEN, DELIM_NONE ) );
AddTopologyNotificationEncap( MgmtProtocol::CMgmtPMessage::EVENT_REGISTER,
GetFarId( ), farAddr, MgmtProtocol::TYPE_GR,
nmsId, MgmtProtocol::TYPE_NMS );
//2) register root with parent far
const TIpv6Prefix& rootAddr = GetRootAddress( );
NLOG_DBG( "Registering root, addr %s as child of far, id %s",
FormatIPv6Prefix( rootAddr.m_oIPv6Addr.m_pucBytes, PrefixLenInBytes( rootAddr.m_u8PrefixLen ) ),
FormatHex( GetFarId( ), IPv6_HOST_ID_LEN, DELIM_NONE ) );
AddTopologyNotificationEncap( MgmtProtocol::CMgmtPMessage::EVENT_REGISTER, NULL,
rootAddr, MgmtProtocol::TYPE_RplRoot, GetFarId( ),
MgmtProtocol::TYPE_GR );
m_shpoCnsTopoNotifMsg->m_uSendMaxRetries = SEND_INFINITE_RETRIES;
m_pMgmtClientLink->SendMessage( m_shpoCnsTopoNotifMsg );
m_shpoCnsTopoNotifMsg->OptionListReset( );
m_shpoCnsTopoNotifMsg->m_uSendMaxRetries = DEFAULT_SEND_MAX_RETRIES;
}
///////////////////////////////////////////////////////////////////////////////
///@author Nicolae Bodislav
///@brief Callback called internally when the write is done or the timeout expires.
///@param transfer - struct libusb_transfer that contains data from the transfer.
///@retval none.
///////////////////////////////////////////////////////////////////////////////
void CUSBLink::Cb_TransferWrite(struct libusb_transfer *transfer)
{
CUSBLink* c = (CUSBLink*)transfer->user_data;
NLOG_DBG("[CUSBLink][Cb_TransferWrite] Data transfer status %d\n", transfer->status);
if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
{
c->Transfer(false, 0);
NLOG_ERR("[CUSBLink][Cb_TransferWrite] Transfer not completed");
}
c->Transfer(false, transfer->actual_length);
}
void FarNetStatRecord :: Init( unsigned int p_unStatPeriodSec )
{
time_t crntTime = time( NULL );
m_unStatPeriodSec = p_unStatPeriodSec;
m_oCrntIntervalStart = crntTime;
if (m_unStatPeriodSec)
{
m_oCrntIntervalStart -= crntTime % m_unStatPeriodSec;
NLOG_DBG("Current time is %i Will push next net Stats at %i, interval is %i", crntTime, (m_oCrntIntervalStart + m_unStatPeriodSec), m_unStatPeriodSec );
}
}
void FarNetStatRecord :: ResetStats()
{
map<TIpv6Addr, NetStatData, CIPv6AddrLess>::iterator it;
for ( it = m_oStatMap.begin(); it != m_oStatMap.end(); ++it )
( *it ).second.ResetStats();
time_t crntTime = time( NULL );
m_oCrntIntervalStart = crntTime;
if (m_unStatPeriodSec)
{
m_oCrntIntervalStart -= crntTime % m_unStatPeriodSec;
NLOG_DBG("Current time is %i Will push next net Stats at %i, interval is %i", crntTime, (m_oCrntIntervalStart + m_unStatPeriodSec), m_unStatPeriodSec );
}
}
bool isRadio (const TIpv6Addr *p_poIPv6Addr)
{
FILE *tmp = fopen("/opt/iprf/activity_files/tranceivers.txt", "r");
const char* mac = FormatHex(p_poIPv6Addr->m_pucBytes + 8, MAC_ADDR_LEN, -1);
NLOG_DBG("looking for MAC %s.", mac);
if (tmp)
{
char ip[255] = {0};
const char* address = FormatIPv6(p_poIPv6Addr);
while (fgets( ip, sizeof(ip),tmp) != NULL)
{
if ((strstr(ip, address) != NULL) || (strstr(ip, mac) != NULL))
{
NLOG_DBG("%s is a transceiver.", address);
fclose (tmp);
return true;
}
}
fclose (tmp);
NLOG_DBG("%s is NOT a transceiver.", address);
}
return false;
}
void CRplNodeRsp::ProcessResponse()
{
IEPDBMngtBase::DBResponse oDBResp;
oDBResp.trackingNo = m_rDevMsg->m_unDBTrackNo;
memcpy(oDBResp.ucBcastDeviceID, m_rDevMsg->m_oDstAddr.GetIPv6() + 8, CNetAddressExt::m_nIPv6AddrLen - 8);
if (!MsgDataToXML(oDBResp.parsedResp, m_rDevMsg->m_isBroadcast))
{ return;
}
if (!m_rDBMngt.SaveDBResp(oDBResp))
{ NLOG_ERR("[RplNodeRsp::ProcessResponse]: failed to save msg for db_trcking_no=%d", oDBResp.trackingNo);
}
else
{ NLOG_DBG("[RplNodeRsp::ProcessResponse]: XML resp: %s", oDBResp.parsedResp.c_str());
}
}
///////////////////////////////////////////////////////////////////////////////
///@author Nicolae Bodislav
///@brief Callback called internally when the read is done or the timeout expires.
///@param transfer - struct libusb_transfer that contains data from the transfer.
///@retval none.
///////////////////////////////////////////////////////////////////////////////
void CUSBLink::Cb_TransferRead(struct libusb_transfer *transfer)
{
CUSBLink* c = (CUSBLink*)transfer->user_data;
NLOG_DBG("[CUSBLink][Cb_TransferRead] Data transfer status %d\n", transfer->status);
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
if(transfer->status == LIBUSB_TRANSFER_TIMED_OUT)
{ c->Transfer(false, 0);//if timed out then no data
}
else
{ c->Transfer(false, -1);//an error occurred
}
return;
}
c->Transfer(true, transfer->actual_length);
}
void CRplRootNetStat :: SetMgmtMessageData(MgmtProtocol::CMgmtPMessage::Ptr &p_pMessage, FarNetStatRecord &p_rReportedRecord, bool prev)
{
MgmtProtocol::CMgmtPMessage::MsgFarNetStatRespData oMsgNetStat;
//NLOG_INFO( "CRplRootNetStat::SetMgmtMessageData() setting %d records.", p_rReportedRecord.GetNumRecords() );
memcpy(oMsgNetStat.Header().m_pucFarId, g_pApp->GetFarId(), IPV6_DEVID_LEN);
oMsgNetStat.Header().m_u32StartTime = prev ? GetPrevPeriodStart() : GetCrntPeriodStart();
oMsgNetStat.Header().m_u32EndTime = prev ? GetPrevPeriodEnd() : GetCrntPeriodEnd();
if (p_rReportedRecord.GetNumRecords())
{
oMsgNetStat.AllocRecords(p_rReportedRecord.GetNumRecords());
int i;
map<TIpv6Addr, NetStatData, CIPv6AddrLess>::const_iterator it;
for (i = 0, it = p_rReportedRecord.m_oStatMap.begin(); it != p_rReportedRecord.m_oStatMap.end(); i++, ++it)
{
NLOG_DBG( "CRplRootNetStat::SetMgmtMessageData() addr %s from %d to %d srh err %d last rcv %d.",
FormatIPv6( &it->first ),
( *it ).second.m_nPacketsFrom,
( *it ).second.m_nPacketsTo,
( *it ).second.m_nSrhErrors,
( *it ).second.m_oLastRcvMsg );
memcpy(oMsgNetStat.Record( i ).m_pucDevId, &( *it ).first.m_pucBytes[IPV6_ADDR_LEN - IPV6_DEVID_LEN], IPV6_DEVID_LEN);
oMsgNetStat.Record( i ).m_u16MsgFromDev = ( *it ).second.m_nPacketsFrom;
oMsgNetStat.Record( i ).m_u16MsgToDev = ( *it ).second.m_nPacketsTo;
oMsgNetStat.Record( i ).m_u16RplMsgFromDev = ( *it ).second.m_nRplPacketsFrom;
oMsgNetStat.Record( i ).m_u16RplMsgToDev = ( *it ).second.m_nRplPacketsTo;
oMsgNetStat.Record( i ).m_u16SrcRouteErr = ( *it ).second.m_nSrhErrors;
oMsgNetStat.Record( i ).m_u32LastRcvMsg = ( *it ).second.m_oLastRcvMsg;
oMsgNetStat.Record( i ).m_u32BytesFromMsgFromDev = ( *it ).second.m_nBytesFromPacketsFrom;
oMsgNetStat.Record( i ).m_u32BytesFromMsgToDev = ( *it ).second.m_nBytesFromPacketsTo;
oMsgNetStat.Record( i ).m_u32BytesFromRplMsgFromDev = ( *it ).second.m_nBytesFromRplPacketsFrom;
oMsgNetStat.Record( i ).m_u32BytesFromRplMsgToDev = ( *it ).second.m_nBytesFromRplPacketsTo;
}
}
p_pMessage->SetData(&oMsgNetStat);
}
void FarNetStatRecord :: AddRplPacketTo( const TIpv6Addr &p_roAddress )
{
m_oStatMap[p_roAddress].m_nRplPacketsTo++;
NLOG_DBG("NetStat: Rpl To=%s, pkt=%d", FormatIPv6(p_roAddress.m_pucBytes), m_oStatMap[p_roAddress].m_nRplPacketsTo);
}
void FarNetStatRecord :: AddBytesFromRplPacketFrom( const TIpv6Addr &p_roAddress, unsigned int p_unBytesNo )
{
m_oStatMap[p_roAddress].m_nBytesFromRplPacketsFrom += p_unBytesNo;;
NLOG_DBG("NetStat: Rpl From=%s, pkt=%d", FormatIPv6(p_roAddress.m_pucBytes), m_oStatMap[p_roAddress].m_nBytesFromRplPacketsFrom);
}
void FarNetStatRecord :: AddBytesFromPacketTo( const TIpv6Addr &p_roAddress, unsigned int p_unBytesNo )
{
m_oStatMap[p_roAddress].m_nBytesFromPacketsTo += p_unBytesNo;
NLOG_DBG("NetStat: To=%s, pkt=%d", FormatIPv6(p_roAddress.m_pucBytes), m_oStatMap[p_roAddress].m_nBytesFromPacketsTo);
}
void FarNetStatRecord :: AddRplPacketFrom( const TIpv6Addr &p_roAddress )
{
m_oStatMap[p_roAddress].m_nRplPacketsFrom++;
m_oStatMap[p_roAddress].m_oLastRcvMsg = time( NULL );
NLOG_DBG("NetStat: Rpl From=%s, pkt=%d", FormatIPv6(p_roAddress.m_pucBytes), m_oStatMap[p_roAddress].m_nRplPacketsFrom);
}
