Ejemplo n.º 1
0
static void TSCHtimeslotIE_HtoLE(uint8_t *p_pu8Buff, int p_nLen)
{
    if (p_nLen == 1)
    {   return;
    }
    else if (p_nLen == sizeof(TSCHtimeslotIE))
    {
        TSCHtimeslotIE *pTSCH = (TSCHtimeslotIE *) p_pu8Buff;
        pTSCH->m_unCCAOffset          = HtoLEs(pTSCH->m_unCCAOffset);
        pTSCH->m_unCCADuration        = HtoLEs(pTSCH->m_unCCADuration);
        pTSCH->m_unTxOffset           = HtoLEs(pTSCH->m_unTxOffset);
        pTSCH->m_unRxOffset           = HtoLEs(pTSCH->m_unRxOffset);
        pTSCH->m_unRxAckDelay         = HtoLEs(pTSCH->m_unRxAckDelay);
        pTSCH->m_unTxAckDelay         = HtoLEs(pTSCH->m_unTxAckDelay);
        pTSCH->m_unRxWait             = HtoLEs(pTSCH->m_unRxWait);
        pTSCH->m_unRxAckWait          = HtoLEs(pTSCH->m_unRxAckWait);
        pTSCH->m_unRxToTx             = HtoLEs(pTSCH->m_unRxToTx);
        pTSCH->m_unMaxTxAckDuration   = HtoLEs(pTSCH->m_unMaxTxAckDuration);
        pTSCH->m_unMaxTxDPDUDuration  = HtoLEs(pTSCH->m_unMaxTxDPDUDuration);
        pTSCH->m_unTimeslotLen        = HtoLEs(pTSCH->m_unTimeslotLen);
    }
    else
    {
        NLOG_ERR("TSCHtimeslotIE LE conversion: expected %d bytes, got %d ",
                 sizeof(TSCHtimeslotIE), p_nLen);
    }
}
Ejemplo n.º 2
0
static void Slotframes_HtoLE(uint8_t *p_pu8Buff, int p_nLen)
{
    int nSlotFrames = *p_pu8Buff++;

    if (p_nLen < (int) (nSlotFrames * sizeof(TMacSlotframeInfo)))
    {
        NLOG_ERR("Slotframes LE conversion: expected at least %d bytes, got %d ",
                 nSlotFrames * sizeof(TMacSlotframeInfo), p_nLen);
        return;
    }

    for (int i = 0; i < nSlotFrames; i++)
    {
        TMacSlotframeInfo *pSFInfo = (TMacSlotframeInfo *) p_pu8Buff;
        pSFInfo->m_u16SlotframeSize = HtoLEs(pSFInfo->m_u16SlotframeSize);
        p_pu8Buff += sizeof(TMacSlotframeInfo);

        for (int j = 0; j < pSFInfo->m_u8LinksNo; j++)
        {
            TMacLinkInfo *pLinkInfo = (TMacLinkInfo *) p_pu8Buff;
            pLinkInfo->m_u16Timeslot       = HtoLEs(pLinkInfo->m_u16Timeslot);
            pLinkInfo->m_u16ChannelOffset  = HtoLEs(pLinkInfo->m_u16ChannelOffset);
            p_pu8Buff += sizeof(TMacLinkInfo);
        }
    }
}
Ejemplo n.º 3
0
void CIPGRegUpdCmd::Execute()
{
	NLOG_INFO("[IPGRegUpdCmd]: received msg = %s",	MsgToStr(m_rMsg).c_str());
	
	
	CMgmtPOption::OptionIPGatewayInfoData *pOpData1 = NULL;
	std::list<CMgmtPOption::OptionIPRoutesListData> rawRouteInfo;
	CMgmtPOption::OptionKeepAliveIntervalData *pOpData2 = NULL;
	if (!ProcessMsg(&pOpData1, rawRouteInfo, &pOpData2))
	{
		if (m_rIPGList.find(CIPGInfo (m_rMsg.m_oNetAddr)) == m_rIPGList.end())
			NLOG_ERR("[IPGRegUpdCmd]: MODULE=%s was not added in CACHE because of invalid register/update INFO ",	AddrToStr(m_rMsg.m_oNetAddr).c_str());
		return;
	}
	
	
	///add module if it doesn't exist 
	CIPGInfo key(m_rMsg.m_oNetAddr);
	std::set<CIPGInfo>::iterator i = m_rIPGList.find(key);
	bool isNewIPG = false;
	if (i == m_rIPGList.end())
	{
		///FIRST
		CTunnelKey info(pOpData1->m_IPGAddrIPv4, pOpData1->m_szIPGAddrIPv6, 128);
		if (m_rFARAndIPGPubInf.insert(info).second == false)
		{
			NLOG_WARN("[IPGRegUpdCmd]: MODULE=%s was not added in CACHE because of duplicated publicInfo=%s, "
				"skip processing msg = %s", AddrToStr(m_rMsg.m_oNetAddr).c_str(), 
							TunnelKeyToStr(info).c_str(), MsgToStr(m_rMsg).c_str());
			return;
		}
	
		isNewIPG = true;
		i = m_rIPGList.insert(CIPGInfo(m_rMsg.m_oNetAddr, CModuleInfo::MT_REGISTERED)).first;
		i->SetPendingTimedout(m_rApp.GetConfig().m_nPendingRelationTimedoutS);
	}

	CIPGInfo *pIPGInfo = (CIPGInfo*)&(*i);
	pIPGInfo->SetTimedOut(CModuleInfo::MTT_KEEP_ALIVE, pOpData2->m_IntSec, pOpData2->m_IntUSec);
	pIPGInfo->SetPublicIpgInfo(*pOpData1);
	if(pIPGInfo->GetState() != CModuleInfo::MT_REGISTERED)
		pIPGInfo->SetState(CModuleInfo::MT_REGISTERED);
		
	
	///process
	std::list<CMgmtPOption::OptionIPRoutesListData> IPGAddedRoute;
	std::list<CMgmtPOption::OptionIPRoutesListData> IPGEraseRoute;
	ProcessRegIPG(i, isNewIPG, rawRouteInfo, IPGAddedRoute, IPGEraseRoute);
	
	NLOG_INFO("[IPGRegUpdCmd]: raw(routes=%d), add(routes=%d), erase(routes=%d)", rawRouteInfo.size(), IPGAddedRoute.size(), IPGEraseRoute.size());
	
	///send result
	if (IPGAddedRoute.size() > 0)
		//SendAddTunnOnIPG(m_rMsg.m_oNetAddr, IPGAddedTun); -- not add only the difference but all
		SendSetTunnOnIPG(i);
		
	if (IPGEraseRoute.size() > 0)
		SendDelTunnOnIPG(m_rMsg.m_oNetAddr, IPGEraseRoute, m_rApp);
	
}
Ejemplo n.º 4
0
bool CTun::checkRead (unsigned int p_nTimeout)
{
	if (m_nTunHandle == -1) return false;

	fd_set readfds;
	struct timeval tmval;

	tmval.tv_usec = p_nTimeout%1000000;
	tmval.tv_sec = p_nTimeout/1000000;

	FD_ZERO(&readfds);
	FD_SET(m_nTunHandle, &readfds);

	int nSelected = ::select( m_nTunHandle +1, &readfds, NULL, NULL, &tmval);

	if ( -1 == nSelected )
	{
		NLOG_ERR("CTun::checkRead(fd %u)", m_nTunHandle);
		if (errno == EINTR )
		{
			return false;
		}
		Close();
		return false;
	}
	return FD_ISSET( m_nTunHandle, &readfds );
}
Ejemplo n.º 5
0
//////////////////////////////////////////////////////////////////////////////
/// @brief Will try to connect using the socket that should be used
/// @retval true if everything is ok, false otherwise
/// @param [in] p_szHost Host where to connect (IP of hostname)
/// @param [in] p_nPort Destination port to connect
/// @param [in] p_nTimeout Timeout expressed in seconds for connection
//////////////////////////////////////////////////////////////////////////////
bool CAbstractSocket::Connect(const char *p_szHost, unsigned short p_nPort, unsigned short p_nTimeout /*= 10*/)
{	
	// Check parameters
	
	if(p_szHost == NULL || p_szHost[0] == 0 || p_nPort == 0)
	{
		NLOG_WARN("Cannot connect to NULL host or port 0.");
		return false;
	}
	
	if(m_bSSLFlag) 
	{
		bool bConnect = m_oSecureSocket.Connect(p_szHost, p_nPort, p_nTimeout);
		
		if(!bConnect) return false;
		
		if(!m_oSecureSocket.BlockUntilSSLServerHandshakeCompletes())
		{
			NLOG_ERR("Cannot block until SSL handshake completes!");
			return false;
		}
		
		return bConnect;
	}
	else return m_oNormalSocket.Connect(p_szHost, p_nPort, p_nTimeout);
}
Ejemplo n.º 6
0
bool CSumiUtils::APISendDeactivateLogs(uint8_t p_u8SerialMsgId, CBufferedSerialLink *p_poBufferedSerialLink)
{
    //msg header
	API_MSG_HDR *pHdr = (API_MSG_HDR*)m_pucSendBuf;
	SET_API_HDR(pHdr, API_DEBUG, API_MSG_REQ, API_DEACTIVATE_LOG, p_u8SerialMsgId, 0);
    //send msg
    if( !p_poBufferedSerialLink->IsLinkOpen() )
    {	NLOG_ERR("LINK NOT OPEN!");
        return false;
	}
    int nSentLen = p_poBufferedSerialLink->Write(m_pucSendBuf, sizeof(API_MSG_HDR));
    if ( nSentLen <=0 )
    {   NLOG_ERR("FAILED TO SEND API_DEACTIVATE_LOGS ON SERIAL LINK!");
        return false;
    }
    return true;
}
Ejemplo n.º 7
0
void CEPInfo::InsertRelatFAR(const CNetAddressExt&p_rAddr)const
{
	if (m_relatedFARs.insert(p_rAddr).second == false)
	{
		NLOG_ERR("[InsertRelatFAR]: related far (source_addr=%s) is already in related FAR list on EP!", AddrToStr(p_rAddr).c_str());
		assert(false);
	}
}
Ejemplo n.º 8
0
CMutexWrapper::~CMutexWrapper()
{
    int result;
    if ( ( result = pthread_mutex_destroy(&m_oMutex) ) != 0 )
    {
        NLOG_ERR( "%s, pthread_mutex_destroy() failed with result %d.", __PRETTY_FUNCTION__, result );
    }
}
Ejemplo n.º 9
0
bool CNMS_DBMngt::GetSystemSetProp(unsigned int &val)
{
	IDbSPHelper *pHelper = Connect();
	if (pHelper == NULL)
		return false;
	
	//
	pHelper->CreateSPCommand("GetSystemSettingsProperty");
		
	if (!pHelper->AddINParam(1, "NetworkPrefixesTimestamp"))
	{	NLOG_ERR("NMS_DBMngt:GetSystemSetProp: failed to add param for sp -> GetSystemSettingsProperty!");
		delete pHelper;
		return false;
	}
	
	char szValue[70];
	if (!pHelper->AddOUTParam(2, (char*)szValue, (int)sizeof(szValue)))
	{	NLOG_ERR("NMS_DBMngt:GetSystemSetProp: failed to add param for sp -> GetSystemSettingsProperty!");
		delete pHelper;
		return false;
	}
	
	int errCode = 0;
	if (!pHelper->AddOUTParam(3, &errCode))
	{	NLOG_ERR("NMS_DBMngt:GetSystemSetProp: failed to add param for sp -> GetSystemSettingsProperty!");
		delete pHelper;
		return false;
	}

	if (!pHelper->ExecuteQuery())
	{	NLOG_ERR("NMS_DBMngt:GetSystemSetProp: failed to execute query for sp -> GetSystemSettingsProperty!");
		delete pHelper;
		return false;
	}
	
	if (errCode == 1)
	{	NLOG_ERR("NMS_DBMngt:GetSystemSetProp: failed to execute query for sp -> GetSystemSettingsProperty! with err=%d", errCode);
		delete pHelper;
		return false;
	}
	sscanf(szValue, "%u", &val);
	NLOG_INFO("szValue=%s, and int=%d", szValue, val);
	
	delete pHelper;
	return true;
}
Ejemplo n.º 10
0
//////////////////////////////////////////////////////////////////////////////
/// @brief Parse the current CRadioMessage and creates a string 
/// @param [in] If true and message encrypted  will display it decrypted
/// @retval The string describing object structure information - detalied
//////////////////////////////////////////////////////////////////////////////
string CRadioMessage::ToString(bool p_bDecrypt /*= false*/)
{
	ostringstream oBuf;
	uint8_t *pu8DecryptedPayload = NULL;
	uint32_t u32DecryptedLength = 0;
	bool bEncryptedWithDefaultKey = false;
	
	oBuf << TypeStr()    << " CRadioMessage [ ID: " << m_u32ID << " ] ";
	oBuf << " Time: " << m_u32ReceivedTime << " ";
	
	if(m_u1HMAC)       oBuf << "<HMAC> ";
	if(m_u1Signed)     oBuf << "<Signed> ";
	if(m_u1Compressed) oBuf << "<Compressed> ";
	if(m_u1Encrypted)  oBuf << "<Encrypted> ";
	
	// All useful information
	
	oBuf << "\nRemote: " << CAdapterUtil::IntToHexStr(m_u32RemoteLANAddress) << " [" << CAdapterUtil::Int64ToHexStr(m_u64RemoteWANAddress) << "]" << ", ";
	oBuf << "Local:  "   << CAdapterUtil::IntToHexStr(m_u32LocalLANAddress)  << " [" << CAdapterUtil::Int64ToHexStr(m_u64LocalWANAddress)  << "]" << "\n";
	
	oBuf << "Priority: " << (int)m_u8Priority  << ", TTL: " << m_u16TimeToLive << ", Hops: " << (int)m_u8MaxHops;
	oBuf << ", Mood: "   << (int)m_u8Mood << ", Receipt: " << (int)m_u8ReturnReceipt;
	
	// Check if it is a small/big resident DCW
	
	if(m_u32RemoteLANAddress == 0xFEFEFE7D)      oBuf << " <Small DCW>";
	else if(m_u32RemoteLANAddress == 0xFEFEFE7E) oBuf << " <Big DCW>";
	
	// Display hex formatted payload
	
	oBuf << ", Payload " << ((p_bDecrypt && m_u1Encrypted) ? "<Decrypted>" : "" ) << ": \n" << "------------------------------------------------------------------------\n";
	
	if(p_bDecrypt && m_u1Encrypted)
	{	
		// Decrypt packet
					
		u32DecryptedLength = m_u32PayloadLength - ENC_HMAC_SIZE_USED + AES_BLOCK_SIZE;
		pu8DecryptedPayload = new uint8_t[u32DecryptedLength];
			
		if(!CEncryption::LGDecrypt(m_pu8Payload, m_u32PayloadLength, m_u32RemoteLANAddress, m_u32ID, m_u8ReturnReceipt, 
				m_u4MessageType, m_u1Encrypted, pu8DecryptedPayload, u32DecryptedLength, bEncryptedWithDefaultKey))
		{
			NLOG_ERR("Cannot decrypt packet to display data!");
			
			oBuf << CAdapterUtil::GetFormattedHex(m_pu8Payload, m_u32PayloadLength);
		}
		else 
		{
			NLOG_INFO("Packet was succesfully decrypted to be displayed.");
			oBuf << CAdapterUtil::GetFormattedHex(pu8DecryptedPayload, u32DecryptedLength);
		}
		
		delete[] pu8DecryptedPayload;
	}
	else oBuf << CAdapterUtil::GetFormattedHex(m_pu8Payload, m_u32PayloadLength);
	
	return oBuf.str();
}
Ejemplo n.º 11
0
bool CTun::collectIp6Packet(IpPacket::IPv6* p_poPacket, ssize_t br)
{
	if (br < (ssize_t)offsetof(IpPacket::IPv6, m_oIP_Payload))
	{
		NLOG_WARN("CTun::collectIp6Packet, [IP] header too small: expected(0x%04x), received(0x%04x)", offsetof(IpPacket::IPv6, m_oIP_Payload), br);
		return false;
	}
	// verify packet length
	uint16_t rcvLen = ntohs(p_poPacket->m_u16_PayloadLength);
	if(rcvLen + (ssize_t)offsetof(IpPacket::IPv6, m_oIP_Payload) != br)
	{
		NLOG_WARN("CTun::collectIp6Packet, [IP] packet size wrong: expected(0x%04x), received(0x%04x)", rcvLen + offsetof(IpPacket::IPv6, m_oIP_Payload), br);
		return false;
	}
	// verify checksums
	Ip6PseudoHdr oPHdr(p_poPacket);
	uint16_t rcvChecksum;
	// pseudoheader checksum
	uint16_t expChecksum =  IpPacket::Checksum((uint8_t*)&oPHdr, sizeof oPHdr);
	switch(p_poPacket->m_u8_NextHeader)
	{
		case IPPROTO_ICMPV6:
		{
			rcvChecksum = ntohs(p_poPacket->m_oICMP_Payload.m_u16_Checksum);
			p_poPacket->m_oICMP_Payload.m_u16_Checksum = 0;
			expChecksum = IpPacket::Checksum((const uint8_t*)(&p_poPacket->m_oICMP_Payload), rcvLen, expChecksum);
			if (expChecksum != rcvChecksum)
			{
				NLOG_WARN("CTun::collectIp6Packet, [ICMP] incorrect checksum: expected(0x%04x), received(0x%04x)", expChecksum, rcvChecksum);
				return false;
			}
			p_poPacket->m_oICMP_Payload.m_u16_Checksum = htons(rcvChecksum);
			break;
		}
		case IPPROTO_UDP:
		{
			rcvChecksum = ntohs(p_poPacket->m_oUDP_Payload.m_u16_Checksum);
			if (!rcvChecksum){
				//IPv6 receivers must discard UDP packets containing a zero checksum, and should log the error.
				NLOG_ERR("CTun::collectIp6Packet, [UDP] incorrect zero checksum: packet discarded");
				return false;
			};
			p_poPacket->m_oUDP_Payload.m_u16_Checksum = 0;
			expChecksum = IpPacket::Checksum((uint8_t*)&p_poPacket->m_oUDP_Payload, rcvLen, expChecksum);
			if(!expChecksum ) expChecksum = 0xFFFF;
			if (expChecksum != rcvChecksum)
			{
				NLOG_WARN("CTun::collectIp6Packet, [UDP] incorrect checksum: expected(0x%04x), received(0x%04x)", expChecksum, rcvChecksum);
				return false;
			}
			p_poPacket->m_oUDP_Payload.m_u16_Checksum = htons(rcvChecksum);
			break;
		}
		default:;
	}
	return true;
}
Ejemplo n.º 12
0
//read
uint16_t NewBroadcastID()
{
	uint32_t val = m_oPersistentMsgId.GetNextMsgId();
	if(val < BID_MIN_ID || val > BID_MAX_ID)
	{	NLOG_ERR("NewBroadcastID: invalid msg_id");
		return 0;
	}
	return (uint16_t)val;
}
Ejemplo n.º 13
0
void CEPInfo::InsertRelatedNS(const CNSPeerKey &p_rkey, const CNetAddressExt/*SS sourceAddres*/&p_rAddr)const
{
	std::pair<CNSPeerKey/*NS INFO*/, CNetAddressExt/*SS sourceAddres*/> relatedNSElem(p_rkey, p_rAddr);				
	if (m_relatedNSs.insert(relatedNSElem).second == false)
	{	NLOG_ERR("[InsertRelateNS]: NS peerkey (ipv6=%s, port=%d) is already in related NS list on EP!", 
				AddrToStr(p_rkey.GetIPv6Addr()).c_str(), p_rkey.GetIPv6Addr().GetPort());
		assert(false);
	}
}
Ejemplo n.º 14
0
///////////////////////////////////////////////////////////////////////////////
///@author      Ghervase Gabriel
///@brief       Checks if a full messasge can be read from the usb
///@param       [in]p_nMiliSec - How much to wait for data before abandoning the operation
///@retval      false  if no data or error
///@retval      true  if we have data
///////////////////////////////////////////////////////////////////////////////
bool CFragmentedUSBLink::HaveData(unsigned int p_nMiliSec/* = 10*/)
{
	if (m_bHaveFullPacket)
	{	return m_bHaveFullPacket;
	}

    USBFragment ofragment;

    while (getFragment(ofragment, p_nMiliSec))
    {
        //check messageId - if unexpected, drop previously read data and restart with new messageID
        if (m_nExpectedMessageId != ofragment.msgId)
        {
            //dump previously received data (if any)
			dropExistingReadData();
			m_nExpectedMessageId = ofragment.msgId;
        }

        // ignore - duplicate packet received
        if (ofragment.pktNo < m_u8ExpectedPktNo)
        {   continue;
        }

        // packets should arrive in order ; dump previously received data if not
        if (ofragment.pktNo > m_u8ExpectedPktNo)
        {
            NLOG_WARN("[CFragmentedUSBLink][HaveData] Bad pktNo received : %d > expected %d - Discard existing fragments for msgId %d ",
                (int)(ofragment.pktNo), (int)(m_u8ExpectedPktNo), (int)(ofragment.msgId) );
            dropExistingReadData();
			continue;
        }


        if (m_nBytesReceivedSoFar + FRAGMENT_DATA_SIZE > MAX_USB_PACKET_SIZE)
        {   NLOG_ERR("[CFragmentedUSBLink][HaveData] Internal Buffer too small; is %d and we need %d - Discard existing fragments for msgId %d",
                (int)MAX_USB_PACKET_SIZE, (int)(m_nBytesReceivedSoFar + FRAGMENT_DATA_SIZE), (int)(ofragment.msgId));
            dropExistingReadData();
			continue;
        }

        memcpy(m_pu8ReadBuf + m_nBytesReceivedSoFar, ofragment.data, FRAGMENT_DATA_SIZE);

        m_nBytesReceivedSoFar += FRAGMENT_DATA_SIZE;
        m_u8ExpectedPktNo++;

        if (ofragment.notLastFragment)
        {   continue;
        }

		//we have received the last fragment
		m_bHaveFullPacket = true;
		break;
    }

    return m_bHaveFullPacket;
}
Ejemplo n.º 15
0
void CEPInfo::InsertPendRelatNS(const CNSPeerKey &p_rkey)const
{
	if (m_pendingRelatedNSs.insert(p_rkey).second == false)
	{	NLOG_ERR("[InsertPendRelatNS]: NS peerkey (ipv6=%s, port=%d) is already in pending related NS list on EP!", 
				AddrToStr(p_rkey.GetIPv6Addr()).c_str(), p_rkey.GetIPv6Addr().GetPort());
		assert(false);
	}
	
	CCommPendRelat::StartPendRelatCountDown();
}
Ejemplo n.º 16
0
void CEPInfo::MovePendNSToRelNS(const CNSPeerKey &p_rkey, const CNetAddressExt/*SS sourceAddres*/&p_rAddr)const
{
	std::set<CNSPeerKey>::iterator jt = m_pendingRelatedNSs.find(p_rkey);
	if (jt == m_pendingRelatedNSs.end())
	{
		NLOG_ERR("[MovePendNSToRelSS]: there is no pending NS(ipv6=%s, port=%d) on ep__module_addr=%s", 
					AddrToStr(p_rkey.GetIPv6Addr()).c_str(), p_rkey.GetIPv6Addr().GetPort(), AddrToStr(m_addr).c_str());
		assert(false);
	}
	
	std::pair<CNSPeerKey,CNetAddressExt> relatedNS(*jt, p_rAddr);
	if (m_relatedNSs.insert(relatedNS).second==false)
	{	NLOG_ERR("[MovePendNSToRelNS]: SS peerkey (ipv6=%s, port=%d) in both SS list on EP!", 
				AddrToStr(p_rkey.GetIPv6Addr()).c_str(), p_rkey.GetIPv6Addr().GetPort());
		assert(false);
	}
	
	m_pendingRelatedNSs.erase(jt);
}
Ejemplo n.º 17
0
///////////////////////////////////////////////////////////////////////////////
///@author      Ghervase Gabriel
///@brief       < operator
///@retval      true fragments are <
///@retval      false fragments not <
///@param       [in] p_rRight - fragment to compare to
///////////////////////////////////////////////////////////////////////////////
bool CFragment::operator<(const CFragment& p_rRight) const
{
    if ( (memcmp(GetSrcAddr(), p_rRight.GetSrcAddr(), p_rRight.GetAddressSize()) != 0) ||
         GetMessageId() != p_rRight.GetMessageId() )
    {   NLOG_ERR ("[Fragment] - Cannot compare fragments belonging to different messages");
        return false;
    }

    return GetFragmentId() < p_rRight.GetFragmentId();
}
Ejemplo n.º 18
0
bool CSumiUtils::SendACK(uint8_t p_u8AckMsgId, CBufferedSerialLink *p_poBufferedSerialLink)
{
    //compose ack
	//uint8_t u8AckMsgId = API_GET_MESSAGE_ID(pHdr);
	API_MSG_HDR *pHdr = (API_MSG_HDR*)m_pucSendBuf;
	SET_API_HDR(pHdr, API_ACK, API_MSG_RSP, DATA_OK, p_u8AckMsgId, 0); 
	//check link
	if( !p_poBufferedSerialLink->IsLinkOpen() )
	{	NLOG_ERR("SendACK: LINK NOT OPEN!");
		return -1;
	}
	//send ack
	int nSentLen = p_poBufferedSerialLink->Write(m_pucSendBuf, sizeof(API_MSG_HDR));
	if ( nSentLen <=0 )
	{   NLOG_ERR("SendACK: FAILED TO SEND ON SERIAL LINK!");
        return false;
    }
	return true;
}
Ejemplo n.º 19
0
void CFARDefaultTunnProc::DeleteIPGKey(const CTunnelKey &p_rIPGKey)
{
	std::map<CTunnelKey, unsigned int>::iterator it = m_IPGsLoad.find(p_rIPGKey);
	if (it == m_IPGsLoad.end())
	{
		NLOG_ERR("[DeleteIPGKey]: ipg_key=%s not found!", TunnelKeyToStr(p_rIPGKey).c_str());
		assert(false);
	}
	
	m_IPGsLoad.erase(it);
}
Ejemplo n.º 20
0
void CEPInfo::EraseRelatedNS(const CNSPeerKey &p_rkey)const
{
	std::map<CNSPeerKey/*NS INFO*/, CNetAddressExt/*SS sourceAddres*/>::iterator jt = m_relatedNSs.find(p_rkey);
	if (jt == m_relatedNSs.end())
	{
		NLOG_ERR("[EraseRelatedNS]: trying to erase NS(ipv6=%s, port=%d) from related ep list on ep_module with addr=%s", 
				AddrToStr(p_rkey.GetIPv6Addr()).c_str(), p_rkey.GetIPv6Addr().GetPort(), AddrToStr(m_addr).c_str());
		assert(false);
	}
	m_relatedNSs.erase(jt);
}
Ejemplo n.º 21
0
///////////////////////////////////////////////////////////////////////////////////
// Name:        Unlock
// Author:      Ghervase Gabriel
// Description: release lock on mutex
// Parameters:  none
// Return:      true - lock was acquired
//              false - lock was not acquired, or fail
//////////////////////////////////////////////////////////////////////////////////
bool CMutexWrapper::Unlock()
{
    int result;
    if ( ( result = pthread_mutex_unlock(&m_oMutex) ) != 0 )
    {
        NLOG_ERR( "%s, pthread_mutex_unlock() failed with result %d.", __PRETTY_FUNCTION__, result );
        return false;
    }

    return true;
}
Ejemplo n.º 22
0
void CEPInfo::ErasePendRelatNS(const CNSPeerKey &p_rkey)const
{
	std::set<CNSPeerKey>::iterator jt = m_pendingRelatedNSs.find(p_rkey);
	if (jt == m_pendingRelatedNSs.end())
	{
		NLOG_ERR("[ErasePendRelatNS]: trying to erase NS(ipv6=%s, port=%d) from pending ep list on ep_module with addr=%s", 
				AddrToStr(p_rkey.GetIPv6Addr()).c_str(), p_rkey.GetIPv6Addr().GetPort(), AddrToStr(m_addr).c_str());
		assert(false);
	}
	m_pendingRelatedNSs.erase(jt);
}
Ejemplo n.º 23
0
void CEPInfo::EraseRelatedFAR(const CNetAddressExt &p_rAddr)const
{
	std::set<CNetAddressExt>::iterator it = m_relatedFARs.find(p_rAddr);
	if (it == m_relatedFARs.end())
	{
		NLOG_ERR("[EraseRelatedFAR]: related far (source_addr=%s) is not in related FAR list on EP!", AddrToStr(p_rAddr).c_str());
		assert(false);
	}
	
	m_relatedFARs.erase(it);
}
Ejemplo n.º 24
0
void CFARDefaultTunnProc::IncrementLoad(const CTunnelKey &p_rIPGKey)
{
	std::map<CTunnelKey, unsigned int>::iterator it = m_IPGsLoad.find(p_rIPGKey);
	if (it == m_IPGsLoad.end())
	{
		NLOG_ERR("[IncrementLoad]: ipg_key=%s not found!", TunnelKeyToStr(p_rIPGKey).c_str());
		assert(false);
	}
	
	it->second++;
}
Ejemplo n.º 25
0
///////////////////////////////////////////////////////////////////////////////
///@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);
}
Ejemplo n.º 26
0
void RegExt_LEtoH(uint8_t* p_pu8InBuff, int p_nInLen)
{
	if (p_nInLen < (int) offsetof(TMapRegExt,m_pu8EBIEdata) )
	{
		NLOG_ERR("RegExt_LEtoH: expected at least %d bytes, got %d ",
			sizeof(TMapRegExt), p_nInLen);
		return;
	}
	TMapRegExt *pRegExt = (TMapRegExt *) p_pu8InBuff;

	pRegExt->m_u16AdvIncPeriod = LEtoHs(pRegExt->m_u16AdvIncPeriod);
}
Ejemplo n.º 27
0
//////////////////////////////////////////////////////////////////////////////
/// @brief Create our abstract socket, SSL or not
/// @retval true if everything is ok, false otherwise
/// @param [in] p_nType Socket type, like SOCK_STREAM
/// @param [in] p_nFamily Socket family, like AF_INET
//////////////////////////////////////////////////////////////////////////////
bool CAbstractSocket::Create(int p_nType /*= SOCK_STREAM*/, int p_nFamily /*= AF_INET*/)
{
	if(m_bSSLFlag)
	{
		// Create socket
		
		if(m_oSecureSocket.Create(p_nType, p_nFamily))
		{
			if(!m_oSecureSocket.InitSSL(CTcpSecureSocket::CLIENT_SIDE, NULL, NULL, NULL, TLS_1_0))
			{
				NLOG_ERR("Cannot initialize SSL context!");
				return false;
			}
			
			NLOG_INFO("SSL socket was succesfully created.");
			return true;
		}
		else 
		{
			NLOG_ERR("Cannot create SSL socket!");
			return false;
		}
	}
	
	// TcpSocket
	
	else 
	{
		if(m_oNormalSocket.Create(p_nType, p_nFamily))
		{
			NLOG_INFO("TcpSocket was succesfully created.");
			return true;
		}
		else 
		{
			NLOG_ERR("Cannot create the TcpSocket!");
			return false;
		}
	}
}
Ejemplo n.º 28
0
///////////////////////////////////////////////////////////////////////////////////
// Name:        CMutexWrapper
// Author:      Ghervase Gabriel
// Description: contructor for creating a mutex with explicit attributes
// Parameters:  p_nPrioceiling  - the priority ceiling of initialised mutexes,
//                                which is the minimum priority level at which
//                                the critical section guarded by the mutex is executed
//                                Must be within the maximum range of priorities
//                                defined under the SCHED_FIFO scheduling policy
//              p_nProtocol     - protocol to be followed ; can be one of :
//                                    PTHREAD_PRIO_NONE,
//                                    PTHREAD_PRIO_INHERIT,
//                                    PTHREAD_PRIO_PROTECT
//              p_nPshared      - mutex's process-shared state;
//                                determines whether the mutex can be used to
//                                synchronize threads within the current process
//                                or threads within all processes on the system
//                                Values :
//                                    PTHREAD_PROCESS_PRIVATE,
//                                    PTHREAD_PROCESS_SHARED
//              p_nType         - type of mutex. Values:
//                                    PTHREAD_MUTEX_NORMAL,
//                                    PTHREAD_MUTEX_RECURSIVE,
//                                    PTHREAD_MUTEX_ERRORCHECK,
//                                    PTHREAD_MUTEX_DEFAULT
// Return:      none
//////////////////////////////////////////////////////////////////////////////////
CMutexWrapper::CMutexWrapper(int p_nPrioceiling, int p_nProtocol, int p_nPshared, int p_nType)
{
    int result;
    pthread_mutexattr_t m_pAttr;

    pthread_mutexattr_init(&m_pAttr);
    pthread_mutexattr_setprioceiling(&m_pAttr, p_nPrioceiling);
    pthread_mutexattr_setprotocol(&m_pAttr, p_nProtocol);
    pthread_mutexattr_setpshared(&m_pAttr, p_nPshared);

    if ( ( result = pthread_mutexattr_settype(&m_pAttr, p_nType) ) != 0 )
    {
        NLOG_ERR( "%s, pthread_mutexattr_settype() failed with result %d.", __PRETTY_FUNCTION__, result );
        return;
    }
    
    if ( ( result = pthread_mutex_init(&m_oMutex, &m_pAttr) ) != 0 )
    {
        NLOG_ERR( "%s, pthread_mutex_init() failed with result %d.", __PRETTY_FUNCTION__, result );
        return;
    }
}
Ejemplo n.º 29
0
bool CNMS_DBMngt::DeleteNetPrefix(const unsigned char netPrefix[/*16*/])
{
	IDbSPHelper *pHelper = Connect();
	if (pHelper == NULL)
		return false;
	pHelper->CreateSPCommand("DeleteNetworkPrefix");
	
	
	if (!pHelper->AddINParam(1, netPrefix, 16))
	{	NLOG_ERR("[NMS_DBMngt:DeleteNetPrefix]: failed to add param for sp -> DeleteNetworkPrefix!");
		delete pHelper;
		return false;
	}	
	
	
	if (!pHelper->ExecuteUpdate())
	{	NLOG_ERR("[NMS_DBMngt:DeleteNetPrefix]: failed to execute update for sp -> DeleteNetworkPrefix!");
		delete pHelper;
		return false;
	}
	delete pHelper;
	return true;
}
Ejemplo n.º 30
0
//INIT
bool CSumiUtils::APISendCreateSocket(uint16_t p_u16Port, uint8_t p_u8SerialMsgId, CBufferedSerialLink *p_poBufferedSerialLink)
{
	
	//msg header
	API_MSG_HDR *pUDPCreateSockHdr = (API_MSG_HDR*)m_pucSendBuf;
	SET_API_HDR(pUDPCreateSockHdr, UDP_SPECIFIC, API_MSG_REQ, UDP_CREATE_SOCKET, p_u8SerialMsgId, sizeof(UDP_CREATE_SOCK_PYLD));
	//msg payload
	UDP_CREATE_SOCK_PYLD *pUDPCreateSockPYLD = (UDP_CREATE_SOCK_PYLD*)(m_pucSendBuf + sizeof(API_MSG_HDR));
	UDP_CREATE_SOCK_SET_PORT(pUDPCreateSockPYLD, p_u16Port);

    //check link
    if( !p_poBufferedSerialLink->IsLinkOpen() )
    {	NLOG_ERR("LINK NOT OPEN!");
		return false;
	}
    //send msg
	int nSentLen = p_poBufferedSerialLink->Write(m_pucSendBuf, sizeof(API_MSG_HDR) + sizeof(UDP_CREATE_SOCK_PYLD));
    if ( nSentLen <= 0 )
    {   NLOG_ERR("FAILED TO SEND UDP_CREATE_SOCKET ON SERIAL LINK!");
        return false;
    }
	return true;
}