Beispiel #1
0
//Mark responses to domains Cache
bool __fastcall MarkDomainCache(const char *Buffer, const size_t Length)
{
//Check conditions.
	auto DNS_Header = (pdns_hdr)Buffer;
	if (
	//Not a response packet
		(ntohs(DNS_Header->Flags) & DNS_GET_BIT_RESPONSE) == 0 || 
	//Question Resource Records must be one.
		DNS_Header->Questions != htons(U16_NUM_ONE) || 
	//Not any Answer Resource Records
		DNS_Header->Answer == 0 /* && DNS_Header->Authority == 0 && DNS_Header->Additional == 0 */ || 
	//OPCode must be set Query/0.
		(ntohs(DNS_Header->Flags) & DNS_GET_BIT_OPCODE) != DNS_OPCODE_QUERY || 
	//Truncated bit must not be set.
		(ntohs(DNS_Header->Flags) & DNS_GET_BIT_TC) != 0 || 
	//RCode must be set No Error or Non-Existent Domain.
		(ntohs(DNS_Header->Flags) & DNS_GET_BIT_RCODE) != DNS_RCODE_NOERROR && (ntohs(DNS_Header->Flags) & DNS_GET_BIT_RCODE) != DNS_RCODE_NXDOMAIN)
			return false;

//Initialization(A part)
	DNSCACHE_DATA DNSCacheDataTemp;
	DNSCacheDataTemp.Length = 0;
	DNSCacheDataTemp.ClearCacheTime = 0;
	auto DNS_Query = (pdns_qry)(Buffer + DNS_PACKET_QUERY_LOCATE(Buffer));
	DNSCacheDataTemp.RecordType = DNS_Query->Type;
	uint32_t ResponseTTL = 0;

//Mark DNS A records and AAAA records only.
	if (DNSCacheDataTemp.RecordType == htons(DNS_RECORD_AAAA) || DNSCacheDataTemp.RecordType == htons(DNS_RECORD_A))
	{
		size_t DataLength = DNS_PACKET_RR_LOCATE(Buffer), TTLCounts = 0;
		pdns_record_standard DNS_Record_Standard = nullptr;
		uint16_t DNS_Pointer = 0;

	//Scan all Answers Resource Records.
		for (size_t Index = 0;Index < (size_t)ntohs(DNS_Header->Answer);++Index)
		{
		//Pointer check
			if (DataLength + sizeof(uint16_t) < Length && (UCHAR)Buffer[DataLength] >= DNS_POINTER_BITS)
			{
				DNS_Pointer = ntohs(*(uint16_t *)(Buffer + DataLength)) & DNS_POINTER_BITS_GET_LOCATE;
				if (DNS_Pointer >= Length || DNS_Pointer < sizeof(dns_hdr) || DNS_Pointer == DataLength || DNS_Pointer == DataLength + 1U)
					return false;
			}

		//Resource Records Name(Domain Name)
			DataLength += CheckQueryNameLength(Buffer + DataLength) + 1U;
			if (DataLength + sizeof(dns_record_standard) > Length)
				break;

		//Standard Resource Records
			DNS_Record_Standard = (pdns_record_standard)(Buffer + DataLength);
			DataLength += sizeof(dns_record_standard);
			if (DataLength > Length || DNS_Record_Standard != nullptr && DataLength + ntohs(DNS_Record_Standard->Length) > Length)
				break;

		//Resource Records Data
			if (DNS_Record_Standard->Classes == htons(DNS_CLASS_IN) && DNS_Record_Standard->TTL > 0 && 
				(DNS_Record_Standard->Type == htons(DNS_RECORD_AAAA) && DNS_Record_Standard->Length == htons(sizeof(in6_addr)) || 
				DNS_Record_Standard->Type == htons(DNS_RECORD_A) && DNS_Record_Standard->Length == htons(sizeof(in_addr))))
			{
				ResponseTTL += ntohl(DNS_Record_Standard->TTL);
				++TTLCounts;
			}

			DataLength += ntohs(DNS_Record_Standard->Length);
		}

	//Calculate average TTL.
		if (TTLCounts > 0)
			ResponseTTL = ResponseTTL / (uint32_t)TTLCounts + ResponseTTL % (uint32_t)TTLCounts;
	}

//Set cache TTL.
	if (ResponseTTL == 0) //Only mark A and AAAA records.
	{
		return false;
	}
	else {
		if (Parameter.CacheType == CACHE_TYPE_TIMER)
		{
			if (ResponseTTL * SECOND_TO_MILLISECOND < Parameter.CacheParameter)
				ResponseTTL = (uint32_t)(Parameter.CacheParameter / SECOND_TO_MILLISECOND - ResponseTTL + STANDARD_TIMEOUT / SECOND_TO_MILLISECOND);
		}
		else { //CACHE_TYPE_QUEUE
			if (ResponseTTL < Parameter.HostsDefaultTTL)
				ResponseTTL = Parameter.HostsDefaultTTL - ResponseTTL + STANDARD_TIMEOUT / SECOND_TO_MILLISECOND;
		}
	}

//Initialization(B part)
	if (Length <= DOMAIN_MAXSIZE)
	{
		std::shared_ptr<char> DNSCacheDataBufferTemp(new char[DOMAIN_MAXSIZE]());
		memset(DNSCacheDataBufferTemp.get(), 0, DOMAIN_MAXSIZE);
		DNSCacheDataTemp.Response.swap(DNSCacheDataBufferTemp);
	}
	else {
		std::shared_ptr<char> DNSCacheDataBufferTemp(new char[Length]());
		memset(DNSCacheDataBufferTemp.get(), 0, Length);
		DNSCacheDataTemp.Response.swap(DNSCacheDataBufferTemp);
	}

//Mark to global list.
	if (DNSQueryToChar(Buffer + sizeof(dns_hdr), DNSCacheDataTemp.Response.get()) > DOMAIN_MINSIZE)
	{
	//Domain Case Conversion
		CaseConvert(false, DNSCacheDataTemp.Response.get(), strnlen_s(DNSCacheDataTemp.Response.get(), DOMAIN_MAXSIZE));
		DNSCacheDataTemp.Domain = DNSCacheDataTemp.Response.get();
		memset(DNSCacheDataTemp.Response.get(), 0, DOMAIN_MAXSIZE);
		memcpy_s(DNSCacheDataTemp.Response.get(), PACKET_MAXSIZE, Buffer + sizeof(uint16_t), Length - sizeof(uint16_t));
		DNSCacheDataTemp.Length = Length - sizeof(uint16_t);

	//Minimum supported system of GetTickCount64() is Windows Vista(Windows XP with SP3 support).
	#if (defined(PLATFORM_WIN32) && !defined(PLATFORM_WIN64))
		if (Parameter.FunctionPTR_GetTickCount64 != nullptr)
			DNSCacheDataTemp.ClearCacheTime = (size_t)((*Parameter.FunctionPTR_GetTickCount64)() + ResponseTTL * SECOND_TO_MILLISECOND);
		else 
			DNSCacheDataTemp.ClearCacheTime = GetTickCount() + ResponseTTL * SECOND_TO_MILLISECOND;
	#else
		DNSCacheDataTemp.ClearCacheTime = GetTickCount64() + ResponseTTL * SECOND_TO_MILLISECOND;
	#endif

		std::unique_lock<std::mutex> DNSCacheListMutex(DNSCacheListLock);
	//Check repeating items, delete duque rear and add new item to deque front.
		for (auto DNSCacheDataIter = DNSCacheList.begin();DNSCacheDataIter != DNSCacheList.end();++DNSCacheDataIter)
		{
			if (DNSCacheDataTemp.Domain == DNSCacheDataIter->Domain && DNSCacheDataTemp.RecordType == DNSCacheDataIter->RecordType)
			{
				DNSCacheList.erase(DNSCacheDataIter);
				break;
			}
		}

		if (Parameter.CacheType == CACHE_TYPE_QUEUE)
		{
			while (DNSCacheList.size() > Parameter.CacheParameter)
				DNSCacheList.pop_front();
		}
		else { //CACHE_TYPE_TIMER
		//Minimum supported system of GetTickCount64() is Windows Vista(Windows XP with SP3 support).
		#if (defined(PLATFORM_WIN32) && !defined(PLATFORM_WIN64))
			while (!DNSCacheList.empty() && (Parameter.FunctionPTR_GetTickCount64 != nullptr && (*Parameter.FunctionPTR_GetTickCount64)() >= DNSCacheList.front().ClearCacheTime || 
				GetTickCount() >= DNSCacheList.front().ClearCacheTime))
		#else
			while (!DNSCacheList.empty() && GetTickCount64() >= DNSCacheList.front().ClearCacheTime)
		#endif
				DNSCacheList.pop_front();
		}

		DNSCacheList.push_back(DNSCacheDataTemp);
		DNSCacheList.shrink_to_fit();
		return true;
	}

	return false;
}
void CBacnetInput::OnBnClickedButtonApply()
{
    // TODO: Add your control notification handler code here
    for (int i=0; i<(int)m_Input_data.size(); i++)
    {
        CString cs_temp=m_input_list.GetItemText(i,INPUT_FULL_LABLE);
        char cTemp[255];
        memset(cTemp,0,255);
        WideCharToMultiByte( CP_ACP, 0, cs_temp.GetBuffer(), -1, cTemp, 255, NULL, NULL );
        memcpy_s(m_Input_data.at(i).description,21,cTemp,21);

        cs_temp=m_input_list.GetItemText(i,INPUT_AUTO_MANUAL);
        if(cs_temp.CompareNoCase(_T("Auto"))==0)
        {
            m_Input_data.at(i).auto_manual=0;
        }
        else
        {
            m_Input_data.at(i).auto_manual=1;
        }

        cs_temp=m_input_list.GetItemText(i,INPUT_RANGE);
        int index_number=0;
        for(int j=0; j<(int)sizeof(Input_Range_Array)/sizeof(Input_Range_Array[0]); j++)
        {
            if(cs_temp.CompareNoCase(Input_Range_Array[j])==0)
            {
                index_number=j;
                break;
            }
        }
        m_Input_data.at(i).range = index_number;

        cs_temp=m_input_list.GetItemText(i,INPUT_UNITE);
        index_number=0;
        for(int j=0; j<(int)sizeof(Input_Unit)/sizeof(Input_Unit[0]); j++) //unit单位很多,在列表中查找
        {
            if(cs_temp.CompareNoCase(Input_Unit[j])==0)
            {
                index_number=j;
                break;
            }
        }

        cs_temp = m_input_list.GetItemText(i,INPUT_VALUE);
        m_Input_data.at(i).value = _wtoi(cs_temp);


        cs_temp=m_input_list.GetItemText(i,INPUT_CAL);
        int cal_value = _wtoi(cs_temp);
        m_Input_data.at(i).calibration = cal_value;


        cs_temp=m_input_list.GetItemText(i,INPUT_FITLER);
        int  temp2 = _wtoi(cs_temp);
        m_Input_data.at(i).filter =(int8_t) (log((double)temp2)/log((double)2));


        cs_temp = m_input_list.GetItemText(i,INPUT_DECOM);
        int dec_index=-1;
        for (int m=0; m<(int)sizeof(Decom_Array)/sizeof(Decom_Array[0]); m++)
        {
            if(cs_temp.CompareNoCase(Decom_Array[m])==0)
            {
                dec_index = m;
                break;
            }
        }
        m_Input_data.at(i).decom = dec_index;

        cs_temp=m_input_list.GetItemText(i,INPUT_LABLE);
        char cTemp1[255];
        memset(cTemp1,0,255);
        WideCharToMultiByte( CP_ACP, 0, cs_temp.GetBuffer(), -1, cTemp1, 255, NULL, NULL );
        memcpy_s(m_Input_data.at(i).label,STR_IN_LABEL,cTemp1,STR_IN_LABEL);
    }
    Post_Write_Message(g_bac_instance,WRITEINPUT_T3000,0,19,sizeof(Str_in_point),BacNet_hwd);

}
Beispiel #3
0
void CDlgWorkThreadAI::OnBnClickedButton2()
{
	//查询当前AI池中的数据
	m_lcTimeout.DeleteAllItems();
	m_lcForbiden.DeleteAllItems();

	char szSendMessage[200] = {'\0'};
	char szCommand[100]     = {'\0'};
	sprintf_s(szCommand, 100, "%s GetWorkThreadTO -a", m_pTcpClientConnect->GetKey());
	int nSendLen = (int)strlen(szCommand); 

	memcpy_s(szSendMessage, 200, &nSendLen, sizeof(int));
	memcpy_s(&szSendMessage[4], 200, &szCommand, nSendLen);

	char szRecvBuff[100 * 1024] = {'\0'};
	int nRecvLen = 100 * 1024;
	bool blState = m_pTcpClientConnect->SendConsoleMessage(szSendMessage, nSendLen + sizeof(int), (char*)szRecvBuff, nRecvLen);
	if(blState == false)
	{
		MessageBox(_T(MESSAGE_SENDERROR) , _T(MESSAGE_TITLE_ERROR), MB_OK);
		return;
	}
	else
	{
		int nStrLen       = 0;
		int nPos          = 0;
		int nThreadCount  = 0;
		memcpy_s(&nThreadCount, sizeof(short), &szRecvBuff[nPos], sizeof(short));
		nPos += sizeof(short);

		for(int i = 0; i < nThreadCount; i++)
		{
			int nThreadID    = 0;
			int nCommandID   = 0;
			int nSecond      = 0;
			int nDisposeTime = 0;

			memcpy_s(&nThreadID, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);

			memcpy_s(&nCommandID, sizeof(short), &szRecvBuff[nPos], sizeof(short));
			nPos += sizeof(short);

			memcpy_s(&nSecond, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);

			memcpy_s(&nDisposeTime, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);

			//显示出来
			CString strData;
			strData.Format(_T("%d"), nThreadID);
			m_lcTimeout.InsertItem(i, strData);

			strData.Format(_T("0x%04x"), nCommandID);
			m_lcTimeout.SetItemText(i, 1, strData);
			time_t time2 = nSecond;
			struct tm tm2;
			localtime_s(&tm2, &time2);

			strData.Format(_T("%04d-%02d-%02d %02d:%02d:%02d"), tm2.tm_year + 1900,
				tm2.tm_mon + 1, tm2.tm_mday, tm2.tm_hour, tm2.tm_min, tm2.tm_sec);
			m_lcTimeout.SetItemText(i, 2, strData);
			strData.Format(_T("%d"), nDisposeTime);
			m_lcTimeout.SetItemText(i, 3, strData);
		}

		//显示封禁的
		memcpy_s(&nThreadCount, sizeof(short), &szRecvBuff[nPos], sizeof(short));
		nPos += sizeof(short);

		for(int i = 0; i < nThreadCount; i++)
		{
			int nThreadID    = 0;
			int nCommandID   = 0;
			int nSecond      = 0;

			memcpy_s(&nThreadID, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);

			memcpy_s(&nCommandID, sizeof(short), &szRecvBuff[nPos], sizeof(short));
			nPos += sizeof(short);

			memcpy_s(&nSecond, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);

			//显示出来
			CString strData;
			strData.Format(_T("%d"), nThreadID);
			m_lcForbiden.InsertItem(i, strData);

			strData.Format(_T("0x%04x"), nCommandID);
			m_lcForbiden.SetItemText(i, 1, strData);

			time_t time2 = nSecond;
			struct tm tm2;
			localtime_s(&tm2, &time2);

			strData.Format(_T("%04d-%02d-%02d %02d:%02d:%02d"), tm2.tm_year + 1900,
				tm2.tm_mon + 1, tm2.tm_mday, tm2.tm_hour, tm2.tm_min, tm2.tm_sec);
			m_lcForbiden.SetItemText(i, 2, strData);
		}
	}

}
Beispiel #4
0
/**
 * Please make sure a_data is valid before calling me.
 * @return Modified data placed in m_sendBuffer yes/no
 **/
bool CSocketInfo::OnSending(bool a_ssl, const char* a_data, size_t a_len)
{
	const size_t l_bytesSentBefore = m_bytesSent;

	m_bytesSent += a_len;

	_ASSERT(a_ssl == m_ssl || (m_state == MSCK_TLS_HANDSHAKE && l_bytesSentBefore == 0));

	if(m_state == MSCK_NOT_IRC)
	{
		return false;
	}
	else if(m_state == MSCK_INITIALIZING)
	{
		if(l_bytesSentBefore == 0 && !a_ssl)
		{
			if(a_len >= 7 && (memcmp(a_data, "CAP LS\n", 7) == 0 || memcmp(a_data, "CAP LS\r\n", 8) == 0))
			{
				// well, this was easy.
				m_state = MSCK_IRC_IDENTIFIED;
			}
			else if(*a_data == 22) // SSL/TLS handshake packet!
			// http://en.wikipedia.org/wiki/Transport_Layer_Security#TLS_handshake_in_detail
			{
				m_ssl = true;

				m_state = MSCK_TLS_HANDSHAKE;
			}
			else if(*a_data == 0x04 && a_len > sizeof(socks4_conn_request_t)) // PROXY: SOCKS4/SOCKS4a
			{
				socks4_conn_request_t l_req;
				memcpy_s(&l_req, sizeof(socks4_conn_request_t), a_data, sizeof(socks4_conn_request_t));

				if(l_req.version == 0x04 && l_req.command == 0x01 && l_req.port > 0 && l_req.ip_addr > 0)
				{
					// seems legit enough...

					m_state = MSCK_SOCKS4_HANDSHAKE;
				}
				else
				{
					m_state = MSCK_NOT_IRC;
				}
			}
			else if(*a_data == 0x05 && a_len > sizeof(socks5_greeting_t)) // PROXY: SOCKS5
			{
				socks5_greeting_t l_gre;
				memcpy_s(&l_gre, sizeof(socks5_greeting_t), a_data, sizeof(socks5_greeting_t));

				if(l_gre.version == 0x05 && l_gre.num_auth_methods < 5)
				{
					m_state = MSCK_SOCKS5_GREETING;
				}
				else
				{
					m_state = MSCK_NOT_IRC;
				}
			}
			else if(a_len >= 19 && strncmp("CONNECT ", a_data, 8) == 0) // PROXY: HTTP
			{
				char _dummy1[300];
				unsigned int _dummy2;

				if(sscanf_s(a_data, "CONNECT %299s HTTP/1.%u\r\n", _dummy1, 299, &_dummy2) == 2)
				{
					m_state = MSCK_HTTP_PROXY_HANDSHAKE;
				}
				else
				{
					m_state = MSCK_NOT_IRC;
				}
			}
			else
			{
				// this ain't nothing we know about :(

				INJECT_DEBUG_MSG("Sending unknown initial data packet!");

				m_state = MSCK_NOT_IRC;
			}
		}
		else if(l_bytesSentBefore == 0 && a_ssl && m_sslHandshakeComplete)
			// after the TLS handshake, it's a normal IRC stream, maybe, at least:
		{
			if(a_len >= 7 && (memcmp(a_data, "CAP LS\n", 7) == 0 || memcmp(a_data, "CAP LS\r\n", 8) == 0))
			{
				m_state = MSCK_IRC_IDENTIFIED;
			}
		}
		else if(m_bytesSent > 2048)
		{
			INJECT_DEBUG_MSG("Sent too much data without any signs for IRC activity.");

			m_state = MSCK_NOT_IRC;
		}
	}
	else if(m_state == MSCK_SOCKS5_AUTHENTICATION)
	{
		if(a_len > sizeof(socks5_conn_request_t))
		{
			socks5_conn_request_t l_req;
			memcpy_s(&l_req, sizeof(socks5_conn_request_t), a_data, sizeof(socks5_conn_request_t));

			if(l_req.version == 0x05 && l_req.command == 0x01 && l_req.addr_type <= 0x04 && l_req.reserved1 == 0)
			{
				m_state = MSCK_SOCKS5_CONNECTION;
			}
		}
	}
	
	if(m_state == MSCK_IRC_IDENTIFIED)
	{
		m_sendingBuffer.append(a_data, a_len);

		std::string l_chunk;
		std::string::size_type l_pos;
		while((l_pos = m_sendingBuffer.find("\n")) != std::string::npos)
		{
			std::string l_line = m_sendingBuffer.substr(0, l_pos + 1);
			m_sendingBuffer.erase(0, l_pos + 1);

			INJECT_DEBUG_MSG(l_line);

			char* l_szNewLine = FiSH_DLL::_OnOutgoingIRCLine(m_socket, l_line.c_str(), l_line.size());

			if(l_szNewLine)
			{
				INJECT_DEBUG_MSG("encrypted:"); INJECT_DEBUG_MSG(l_szNewLine);
				l_chunk += l_szNewLine;
				FiSH_DLL::_FreeString(l_szNewLine);
			}
			else
			{
				l_chunk += l_line;
			}
		}

		m_sendBuffer = l_chunk;

		return true;
	}

	return false;
}
Beispiel #5
0
// Process remote attestation message 3
int sp_ra_proc_msg3_req(const sample_ra_msg3_t *p_msg3,
                        uint32_t msg3_size,
                        ra_samp_response_header_t **pp_att_result_msg)
{
    int ret = 0;
    sample_status_t sample_ret = SAMPLE_SUCCESS;
    const uint8_t *p_msg3_cmaced = NULL;
    sample_quote_t *p_quote = NULL;
    sample_sha_state_handle_t sha_handle = NULL;
    sample_report_data_t report_data = {0};
    sample_ra_att_result_msg_t *p_att_result_msg = NULL;
    ra_samp_response_header_t* p_att_result_msg_full = NULL;
    uint32_t i;

    if((!p_msg3) ||
       (msg3_size < sizeof(sample_ra_msg3_t)) ||
       (!pp_att_result_msg))
    {
        return SP_INTERNAL_ERROR;
    }

    // Check to see if we have registered?
    if (!g_is_sp_registered)
    {
        return SP_UNSUPPORTED_EXTENDED_EPID_GROUP;
    }
    do
    {
        // Compare g_a in message 3 with local g_a.
        ret = memcmp(&g_sp_db.g_a, &p_msg3->g_a, sizeof(sample_ec_pub_t));
        if(ret)
        {
            fprintf(stderr, "\nError, g_a is not same [%s].", __FUNCTION__);
            ret = SP_PROTOCOL_ERROR;
            break;
        }
        //Make sure that msg3_size is bigger than sample_mac_t.
        uint32_t mac_size = msg3_size - sizeof(sample_mac_t);
        p_msg3_cmaced = reinterpret_cast<const uint8_t*>(p_msg3);
        p_msg3_cmaced += sizeof(sample_mac_t);

        // Verify the message mac using SMK
        sample_cmac_128bit_tag_t mac = {0};
        sample_ret = sample_rijndael128_cmac_msg(&g_sp_db.smk_key,
                                           p_msg3_cmaced,
                                           mac_size,
                                           &mac);
        if(SAMPLE_SUCCESS != sample_ret)
        {
            fprintf(stderr, "\nError, cmac fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        // In real implementation, should use a time safe version of memcmp here,
        // in order to avoid side channel attack.
        ret = memcmp(&p_msg3->mac, mac, sizeof(mac));
        if(ret)
        {
            fprintf(stderr, "\nError, verify cmac fail [%s].", __FUNCTION__);
            ret = SP_INTEGRITY_FAILED;
            break;
        }

        if(memcpy_s(&g_sp_db.ps_sec_prop, sizeof(g_sp_db.ps_sec_prop),
            &p_msg3->ps_sec_prop, sizeof(p_msg3->ps_sec_prop)))
        {
            fprintf(stderr,"\nError, memcpy failed in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        p_quote = (sample_quote_t *)p_msg3->quote;

        // Check the quote version if needed. Only check the Quote.version field if the enclave
        // identity fields have changed or the size of the quote has changed.  The version may
        // change without affecting the legacy fields or size of the quote structure.
        //if(p_quote->version < ACCEPTED_QUOTE_VERSION)
        //{
        //    fprintf(stderr,"\nError, quote version is too old.", __FUNCTION__);
        //    ret = SP_QUOTE_VERSION_ERROR;
        //    break;
        //}

        // Verify the report_data in the Quote matches the expected value.
        // The first 32 bytes of report_data are SHA256 HASH of {ga|gb|vk}.
        // The second 32 bytes of report_data are set to zero.
        sample_ret = sample_sha256_init(&sha_handle);
        if(sample_ret != SAMPLE_SUCCESS)
        {
            fprintf(stderr,"\nError, init hash failed in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        sample_ret = sample_sha256_update((uint8_t *)&(g_sp_db.g_a),
                                     sizeof(g_sp_db.g_a), sha_handle);
        if(sample_ret != SAMPLE_SUCCESS)
        {
            fprintf(stderr,"\nError, udpate hash failed in [%s].",
                    __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        sample_ret = sample_sha256_update((uint8_t *)&(g_sp_db.g_b),
                                     sizeof(g_sp_db.g_b), sha_handle);
        if(sample_ret != SAMPLE_SUCCESS)
        {
            fprintf(stderr,"\nError, udpate hash failed in [%s].",
                    __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        sample_ret = sample_sha256_update((uint8_t *)&(g_sp_db.vk_key),
                                     sizeof(g_sp_db.vk_key), sha_handle);
        if(sample_ret != SAMPLE_SUCCESS)
        {
            fprintf(stderr,"\nError, udpate hash failed in [%s].",
                    __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        sample_ret = sample_sha256_get_hash(sha_handle,
                                      (sample_sha256_hash_t *)&report_data);
        if(sample_ret != SAMPLE_SUCCESS)
        {
            fprintf(stderr,"\nError, Get hash failed in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        ret = memcmp((uint8_t *)&report_data,
                     (uint8_t *)&(p_quote->report_body.report_data),
                     sizeof(report_data));
        if(ret)
        {
            fprintf(stderr, "\nError, verify hash fail [%s].", __FUNCTION__);
            ret = SP_INTEGRITY_FAILED;
            break;
        }

        // Verify Enclave policy (an attestation server may provide an API for this if we
        // registered an Enclave policy)

        // Verify quote with attestation server.
        // In the product, an attestation server could use a REST message and JSON formatting to request
        // attestation Quote verification.  The sample only simulates this interface.
        ias_att_report_t attestation_report = {0};
        ret = g_sp_extended_epid_group_id->verify_attestation_evidence(p_quote, NULL,
                                              &attestation_report);
        if(0 != ret)
        {
            ret = SP_IAS_FAILED;
            break;
        }
        FILE* OUTPUT = stdout;
        fprintf(OUTPUT, "\n\n\tAtestation Report:");
        fprintf(OUTPUT, "\n\tid: 0x%0x.", attestation_report.id);
        fprintf(OUTPUT, "\n\tstatus: %d.", attestation_report.status);
        fprintf(OUTPUT, "\n\trevocation_reason: %u.",
                attestation_report.revocation_reason);
        // attestation_report.info_blob;
        fprintf(OUTPUT, "\n\tpse_status: %d.",  attestation_report.pse_status);
        // Note: This sample always assumes the PIB is sent by attestation server.  In the product
        // implementation, the attestation server could only send the PIB for certain attestation 
        // report statuses.  A product SP implementation needs to handle cases
        // where the PIB is zero length.

        // Respond the client with the results of the attestation.
        uint32_t att_result_msg_size = sizeof(sample_ra_att_result_msg_t);
        p_att_result_msg_full =
            (ra_samp_response_header_t*)malloc(att_result_msg_size
            + sizeof(ra_samp_response_header_t) + sizeof(g_secret));
        if(!p_att_result_msg_full)
        {
            fprintf(stderr, "\nError, out of memory in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        memset(p_att_result_msg_full, 0, att_result_msg_size
               + sizeof(ra_samp_response_header_t) + sizeof(g_secret));
        p_att_result_msg_full->type = TYPE_RA_ATT_RESULT;
        p_att_result_msg_full->size = att_result_msg_size;
        if(IAS_QUOTE_OK != attestation_report.status)
        {
            p_att_result_msg_full->status[0] = 0xFF;
        }
        if(IAS_PSE_OK != attestation_report.pse_status)
        {
            p_att_result_msg_full->status[1] = 0xFF;
        }

        p_att_result_msg =
            (sample_ra_att_result_msg_t *)p_att_result_msg_full->body;

        // In a product implementation of attestation server, the HTTP response header itself could have
        // an RK based signature that the service provider needs to check here.

        // The platform_info_blob signature will be verified by the client
        // when sent. No need to have the Service Provider to check it.  The SP
        // should pass it down to the application for further analysis.

        fprintf(OUTPUT, "\n\n\tEnclave Report:");
        fprintf(OUTPUT, "\n\tSignature Type: 0x%x", p_quote->sign_type);
        fprintf(OUTPUT, "\n\tSignature Basename: ");
        for(i=0; i<sizeof(p_quote->basename.name) && p_quote->basename.name[i];
            i++)
        {
            fprintf(OUTPUT, "%c", p_quote->basename.name[i]);
        }
#ifdef __x86_64__
        fprintf(OUTPUT, "\n\tattributes.flags: 0x%0lx",
                p_quote->report_body.attributes.flags);
        fprintf(OUTPUT, "\n\tattributes.xfrm: 0x%0lx",
                p_quote->report_body.attributes.xfrm);
#else
        fprintf(OUTPUT, "\n\tattributes.flags: 0x%0llx",
                p_quote->report_body.attributes.flags);
        fprintf(OUTPUT, "\n\tattributes.xfrm: 0x%0llx",
                p_quote->report_body.attributes.xfrm);
#endif
        fprintf(OUTPUT, "\n\tmr_enclave: ");
        for(i=0;i<sizeof(sample_measurement_t);i++)
        {

            fprintf(OUTPUT, "%02x",p_quote->report_body.mr_enclave[i]);

            //fprintf(stderr, "%02x",p_quote->report_body.mr_enclave.m[i]);

        }
        fprintf(OUTPUT, "\n\tmr_signer: ");
        for(i=0;i<sizeof(sample_measurement_t);i++)
        {

            fprintf(OUTPUT, "%02x",p_quote->report_body.mr_signer[i]);

            //fprintf(stderr, "%02x",p_quote->report_body.mr_signer.m[i]);

        }
        fprintf(OUTPUT, "\n\tisv_prod_id: 0x%0x",
                p_quote->report_body.isv_prod_id);
        fprintf(OUTPUT, "\n\tisv_svn: 0x%0x",p_quote->report_body.isv_svn);
        fprintf(OUTPUT, "\n");

        // A product service provider needs to verify that its enclave properties 
        // match what is expected.  The SP needs to check these values before
        // trusting the enclave.  For the sample, we always pass the policy check.
        // Attestation server only verifies the quote structure and signature.  It does not 
        // check the identity of the enclave.
        bool isv_policy_passed = true;

        // Assemble Attestation Result Message
        // Note, this is a structure copy.  We don't copy the policy reports
        // right now.
        p_att_result_msg->platform_info_blob = attestation_report.info_blob;

        // Generate mac based on the mk key.
        mac_size = sizeof(ias_platform_info_blob_t);
        sample_ret = sample_rijndael128_cmac_msg(&g_sp_db.mk_key,
            (const uint8_t*)&p_att_result_msg->platform_info_blob,
            mac_size,
            &p_att_result_msg->mac);
        if(SAMPLE_SUCCESS != sample_ret)
        {
            fprintf(stderr, "\nError, cmac fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        // Generate shared secret and encrypt it with SK, if attestation passed.
        uint8_t aes_gcm_iv[SAMPLE_SP_IV_SIZE] = {0};
        p_att_result_msg->secret.payload_size = 8;
        if((IAS_QUOTE_OK == attestation_report.status) &&
           (IAS_PSE_OK == attestation_report.pse_status) &&
           (isv_policy_passed == true))
        {
            ret = sample_rijndael128GCM_encrypt(&g_sp_db.sk_key,
                        &g_secret[0],
                        p_att_result_msg->secret.payload_size,
                        p_att_result_msg->secret.payload,
                        &aes_gcm_iv[0],
                        SAMPLE_SP_IV_SIZE,
                        NULL,
                        0,
                        &p_att_result_msg->secret.payload_tag);
        }
    }while(0);

    if(ret)
    {
        *pp_att_result_msg = NULL;
        SAFE_FREE(p_att_result_msg_full);
    }
    else
    {
        // Freed by the network simulator in ra_free_network_response_buffer
        *pp_att_result_msg = p_att_result_msg_full;
    }
    return ret;
}
pse_op_error_t sqlite_read_children_of_root(pse_vmc_children_of_root_t* children)
{
    PROFILE_START("sqlite_read_children_of_root");

    int            rc;
    pse_op_error_t ret = OP_SUCCESS;
    sqlite3_stmt*  stat = NULL;
    char           sql_sentence[1024] = {0};
    int            result;
    uint32_t       node_id;
    const void*    ptr_blob_content;
    uint32_t       blob_len;
    uint32_t       record_count = 0;
    uint32_t       read_list_array[2] = {2,3};
    sqlite3        *db = NULL;

    assert(children != NULL);

    ret = sqlite_open_db(&db);
    if(OP_SUCCESS != ret) 
    {
        pse_vmc_db_state = PSE_VMC_DB_STATE_DOWN;
        PROFILE_END("sqlite_read_children_of_root");
        return ret;
    }

    // prepare sql statement
    if (_snprintf_s(sql_sentence, sizeof(sql_sentence), "select * from HASH_TREE_NODE_TABLE where ID IN (2,3) order by ID asc") < 0)
    {
        ret = OP_ERROR_INTERNAL;
        goto clean_up;
    }
    
    // prepare sql statement
    rc = sqlite3_prepare_v2(db, sql_sentence, -1, &stat, 0);
    EXIT_IFNOT_SQLITE_OK(rc, clean_up)

    // query
    while ((result = sqlite3_step(stat)) == SQLITE_ROW)
    {
        // to calculate number of records returned 
        record_count++;
        if (record_count > 2)
        {
            ret = OP_ERROR_INVALID_VMC_DB;
            goto clean_up;
        }

        node_id = sqlite3_column_int(stat, 0);
        // The array read_list_array[] contains {2,3}, and the node id read from DB must be 2 or 3. 
        if (node_id != read_list_array[record_count-1])
        {
            ret = OP_ERROR_INVALID_VMC_DB;
            goto clean_up;
        }

        ptr_blob_content = sqlite3_column_blob(stat, 1);
        if(!ptr_blob_content)
        {
            ret = OP_ERROR_INVALID_VMC_DB;
            goto clean_up;
        }
        blob_len = sqlite3_column_bytes(stat, 1);

        // Child Node
        if(blob_len != INTERNAL_NODE_SIZE)
        {
            ret = OP_ERROR_INVALID_VMC_DB;
            goto clean_up;
        }

        // Copy children
        hash_tree_internal_node_t* internal_node_ptr = NULL;
        if (node_id == 2) 
        {
            internal_node_ptr = &children->left_child.internal;
        }
        else 
        {
            internal_node_ptr = &children->rigth_child.internal;
        }

            if(0 != memcpy_s(internal_node_ptr, 
                            blob_len, 
                            ptr_blob_content, 
                            blob_len))
        {
            ret = OP_ERROR_INTERNAL;
            goto clean_up;
        }

    }

    if (record_count != 2)
    {
        ret = OP_ERROR_INVALID_VMC_DB;
        goto clean_up;
    }

    if (result != SQLITE_DONE)
    {
        ret = OP_ERROR_SQLITE_INTERNAL;
    }
    
clean_up:
    sqlite3_finalize(stat);
    assert(db != NULL);
    sqlite3_close_v2(db);

    PROFILE_END("sqlite_read_children_of_root");
    return ret;
}
Beispiel #7
0
BOOL ParseMacroData(PCHAR szOriginal, SIZE_T BufferSize)
{
	// find each {}
	PCHAR pBrace = strstr(szOriginal, "${");
	if (!pBrace)
		return false;
	unsigned long NewLength;
	BOOL Changed = false;
	//PCHAR pPos;
	//PCHAR pStart;
	//PCHAR pIndex;
	CHAR szCurrent[MAX_STRING] = { 0 };
	MQ2TYPEVAR Result = { 0 };
	do
	{
		// find this brace's end
		PCHAR pEnd = &pBrace[1];
		BOOL Quote = false;
		BOOL BeginParam = false;
		int nBrace = 1;
		while (nBrace)
		{
			++pEnd;
			if (BeginParam)
			{
				BeginParam = false;
				if (*pEnd == '\"')
				{
					Quote = true;
				}
				continue;
			}
			if (*pEnd == 0)
			{// unmatched brace or quote
				goto pmdbottom;
			}
			if (Quote)
			{
				if (*pEnd == '\"')
				{
					if (pEnd[1] == ']' || pEnd[1] == ',')
					{
						Quote = false;
					}
				}
			}
			else
			{
				if (*pEnd == '}')
				{
					nBrace--;
				}
				else if (*pEnd == '{')
				{
					nBrace++;
				}
				else if (*pEnd == '[' || *pEnd == ',')
					BeginParam = true;
			}

		}
		*pEnd = 0;
		strcpy_s(szCurrent, &pBrace[2]);
		if (szCurrent[0] == 0)
		{
			goto pmdbottom;
		}
		if (ParseMacroData(szCurrent, sizeof(szCurrent)))
		{
			unsigned long NewLength = strlen(szCurrent);
			memmove(&pBrace[NewLength + 1], &pEnd[1], strlen(&pEnd[1]) + 1);
			int addrlen = (int)(pBrace - szOriginal);
			memcpy_s(pBrace, BufferSize-addrlen,szCurrent, NewLength);
			pEnd = &pBrace[NewLength];
			*pEnd = 0;
		}
		ZeroMemory(&Result, sizeof(Result));
		Result.Type = 0;
		Result.Int64 = 0;
		if (!ParseMQ2DataPortion(szCurrent, Result) || !Result.Type || !Result.Type->ToString(Result.VarPtr, szCurrent)) {
			strcpy_s(szCurrent, "NULL");
		}
		NewLength = strlen(szCurrent);
		memmove(&pBrace[NewLength], &pEnd[1], strlen(&pEnd[1]) + 1);
		int addrlen = (int)(pBrace - szOriginal);
		memcpy_s(pBrace, BufferSize-addrlen,szCurrent, NewLength);
		Changed = true;

	pmdbottom:;
	} while (pBrace = strstr(&pBrace[1], "${"));
	if (Changed)
		while (ParseMacroData(szOriginal, BufferSize))
		{
		}
	return Changed;
}
void HeightMap::Initialize(char* mapFileName, char* textureFileName, int bitNum/*= 8*/)
{
	D3DXMatrixIdentity(&world);
	texture = TextureManager::GetTexture(textureFileName);
	ZeroMemory(&material, sizeof(D3DMATERIAL9));
	material.Ambient = D3DXCOLOR(0.7f, 0.7f, 0.7f, 1.0f);
	material.Diffuse = D3DXCOLOR(0.7f, 0.7f, 0.7f, 1.0f);
	material.Specular = D3DXCOLOR(0.7f, 0.7f, 0.7f, 1.0f);

	char fullPath[256];
	strcpy_s(fullPath, HEIGHTMAP_DIRECTORY);
	strcat_s(fullPath, mapFileName);

	FILE* fp = nullptr;
	fopen_s(&fp, fullPath, "rb");

	if (fp != nullptr)
	{
		fseek(fp, 0, SEEK_END);
		vertexCount = ftell(fp);
		fseek(fp, 0, SEEK_SET);

		//총 픽셀 개수 보정
		vertexSizeCount = vertexCount / (bitNum / 8);

		mapSize = (int)(sqrt(vertexSizeCount));

		assert(vertexSizeCount == mapSize*mapSize && "가로세로길이가 동일해야 합니다.");

		std::vector<unsigned char> fileData;
		fileData.resize(vertexSizeCount);

		if ( bitNum == 24 )
		{
			int d[3];
			for ( int i = 0; i < vertexSizeCount; ++i )
			{
				d[0] = fgetc(fp);
				d[1] = fgetc(fp) << 8;
				d[2] = fgetc(fp) << 16;
				int a = d[0] | d[1] | d[2];
				fileData[i] = a;
			}
		}
		else if ( bitNum == 16 )
		{
			int d[2];
			for ( int i = 0; i < vertexSizeCount; ++i )
			{
				d[0] = fgetc(fp);
				d[1] = fgetc(fp) << 8;
				int a = d[0] | d[1];
				fileData[i] = a;
			}
		}
		else
		{
			for ( int i = 0; i < vertexSizeCount; ++i )
			{
				fileData[i] = fgetc(fp);
			}
		}
		fclose(fp);

		tileCount = mapSize - 1;

		std::vector<FVF_PositionNormalTexture> fvfVertex;
		fvfVertex.resize(vertexSizeCount);
		vertex.resize(vertexSizeCount);

		for (int z = 0; z < mapSize; ++z)
		{
			for (int x = 0; x < mapSize; ++x)
			{
				int index = z * mapSize + x;
				FVF_PositionNormalTexture v;
				v.pos = D3DXVECTOR3((float)x, fileData[index] * 0.2f, (float)-z);
				v.normal = D3DXVECTOR3(0,1,0);
				v.tex = D3DXVECTOR2(x / (float)tileCount, z / (float)tileCount);

				fvfVertex[index] = v;
				vertex[index] = v.pos;
			}
		}

		//노말값들 갱신
		//필요한건 벡터 4개
		//왼쪽, 오른쪽, 위쪽, 아래쪽

		for (int z = 1; z < tileCount; ++z)
		{
			for (int x = 1; x < tileCount; ++x)
			{
				int index = z * mapSize + x;
				D3DXVECTOR3 left = vertex[index - 1];
				D3DXVECTOR3 right = vertex[index + 1];
				D3DXVECTOR3 front = vertex[index - mapSize];
				D3DXVECTOR3 rear = vertex[index + mapSize];
				D3DXVECTOR3 leftToRight = right - left;
				D3DXVECTOR3 frontToRear = rear - front;
				D3DXVECTOR3 normal;
				D3DXVec3Cross(&normal, &leftToRight, &frontToRear);
				D3DXVec3Normalize(&normal, &normal);

				fvfVertex[index].normal = normal;
			}
		}

		//버벡스 버퍼, 인덱스 버퍼 만들기
		std::vector<DWORD> indexData;
		triangleCount = tileCount * tileCount * 2;
		indexData.resize(triangleCount * 3);
		for (int z = 0; z < tileCount; ++z)
		{
			for (int x = 0, k = 0; x < tileCount; ++x, ++k)
			{
				int _0 = (x + 0) + (z + 0) * mapSize;
				int _1 = (x + 1) + (z + 0) * mapSize;
				int _2 = (x + 0) + (z + 1) * mapSize;
				int _3 = (x + 1) + (z + 1) * mapSize;

				indexData[z * (6 * tileCount) + k] = (_0);
				indexData[z * (6 * tileCount) + ++k] = (_1);
				indexData[z * (6 * tileCount) + ++k] = (_2);

				indexData[z * (6 * tileCount) + ++k] = (_3);
				indexData[z * (6 * tileCount) + ++k] = (_2);
				indexData[z * (6 * tileCount) + ++k] = (_1);
			}
		}
		int bufferSize = fvfVertex.size() * sizeof(FVF_PositionNormalTexture);
		GameManager::GetDevice()->CreateVertexBuffer(
			bufferSize,
			0,
			FVF_PositionNormalTexture::FVF,
			D3DPOOL_MANAGED,
			&vertexBuffer,
			nullptr);
		LPVOID pV;
		vertexBuffer->Lock(0, 0, &pV, 0);
		memcpy_s(pV, bufferSize, &fvfVertex[0], bufferSize);
		vertexBuffer->Unlock();

		bufferSize = indexData.size() * sizeof(DWORD);
		GameManager::GetDevice()->CreateIndexBuffer(
			bufferSize,
			0,
			D3DFMT_INDEX32,
			D3DPOOL_MANAGED,
			&indexBuffer,
			nullptr);
		LPVOID pI;
		indexBuffer->Lock(0, 0, &pI, 0);
		memcpy_s(pI, bufferSize, &indexData[0], bufferSize);
		indexBuffer->Unlock();
	}
}
int CBinFileParser::GetBinFileBuffer(char* pFileBuf, int nFileBufLen)
{
    int nFileBufSize=0;
    CFile binFile;
    if(binFile.Open(m_strFileName,CFile::modeRead))
    {
        const int BUF_LEN = 1024;
        int linenum=1;
        char pBuf[BUF_LEN] = {'\0'};
        int nRet = 0;
        int nCount = 0;
        binFile.Seek(0, CFile::begin);
        while( (nRet = binFile.Read(pBuf, BUF_LEN)) != 0 )
        {
            if (linenum==1)
            {
                m_strASIX.Format(_T("%C%C%C%C"),pBuf[0],pBuf[1],pBuf[2],pBuf[3]);
                for (int i=0; i<20; i++) //¹Ì¶¨³¤¶È20¸ö
                {
                    if (pBuf[256+i]!=0)
                    {
                        CString temp;
                        temp.Format(_T("%C"),pBuf[256+i]);
                        m_strProductName+=temp;
                    }
                    else
                    {
                        break;
                    }
                }
                // m_strProductName.Format(_T("%C%C%C%C%C%C%C%C%C%C%C%C"),pBuf[256+0],pBuf[256+1],pBuf[256+2],pBuf[256+3],pBuf[256+4],pBuf[256+5],pBuf[256+6],pBuf[256+7],pBuf[256+8],pBuf[256+9],pBuf[256+10],pBuf[256+11]);
            }

            memcpy(pFileBuf + nCount, pBuf, nRet);
            nCount += nRet;
            if (nRet < BUF_LEN)
            {
                break;
            }
            ZeroMemory(pBuf, BUF_LEN);
            ++linenum;
        }

        nFileBufSize = nCount;
        binFile.Close();
    }


	int ret_find_in_0x100 = 0;
	for (int i=0;i<2;i++)
	{
		memset(&global_fileInfor,0,sizeof(Bin_Info));
			if(i==0)
				memcpy(&global_fileInfor,&pFileBuf[0x100],sizeof(Bin_Info));
			else if(i == 1)
			    memcpy(&global_fileInfor,&pFileBuf[0x200],sizeof(Bin_Info));
			else
				return -1;

		//if(strlen(global_fileInfor.product_name) > 200)
		//	nFileBufSize = -1;
		//return NO_VERSION_INFO;
		char temocolog[6];
		memcpy_s(temocolog,5,global_fileInfor.company,5);
		temocolog[5] = 0;

		CString Temco_logo;
		MultiByteToWideChar( CP_ACP, 0, (char *)temocolog,
			(int)strlen(temocolog)+1,
			Temco_logo.GetBuffer(MAX_PATH), MAX_PATH );
		Temco_logo.ReleaseBuffer();
		Temco_logo.MakeUpper();
		if(Temco_logo.CompareNoCase(_T("TEMCO")) != 0&&Temco_logo.CompareNoCase(L"CO2")!=0)
		{
			//return NO_VERSION_INFO;
			ret_find_in_0x100 = -1;
		}
		else
			return nFileBufSize;
	}





    return nFileBufSize;
}
	void read(elem_t* dest, size_t dest_size, const elem_t* src, size_t max_count)
	{
		memcpy_s(dest, dest_size, src, max_count);
		read_pos += max_count;
	}
// This routine initializes the sensor to its default properties
NTSTATUS ActivityDevice::Initialize(
    _In_ WDFDEVICE device,              // WDFDEVICE object
    _In_ SENSOROBJECT sensorInstance)   // SENSOROBJECT for each sensor instance
{
    NTSTATUS status = STATUS_SUCCESS;

    SENSOR_FunctionEnter();

    // Initial configuration
    m_FxDevice = device;
    m_SensorInstance = sensorInstance;
    m_Interval = Act_Default_MinDataInterval_Ms;
    m_FirstSample = TRUE;
    m_Started = FALSE;
    m_HistorySizeInRecords = Act_Default_MaxHistoryEntries;
    m_HistoryPowerInuW = Act_Default_Power_uW;
    m_HistoryIntervalInMs = Act_Default_HistoryInterval_Ms;
    m_HistoryStarted = FALSE;
    m_HistoryRetrievalStarted = FALSE;
    m_History.FirstElemIndex = 0;
    m_History.LastElemIndex = 0;
    m_History.NumOfElems = 0;
    m_History.BufferLength = m_HistorySizeInRecords;
    m_hThread = NULL;

    // Initialize the activity simulator
    status = HardwareSimulator::Initialize(device, &m_SimulatorInstance);
    if (!NT_SUCCESS(status))
    {
        TraceError("ACT %!FUNC! HardwareSimulator::Initialize failed %!STATUS!", status);
        status = STATUS_SUCCESS;    // Failed to set up simulator should not fail the driver
    }

    // Create Lock
    status = WdfWaitLockCreate(WDF_NO_OBJECT_ATTRIBUTES, &m_Lock);
    if (!NT_SUCCESS(status))
    {
        TraceError("ACT %!FUNC! WdfWaitLockCreate failed %!STATUS!", status);
    }

    // Create history lock
    if (NT_SUCCESS(status))
    {
        status = WdfWaitLockCreate(WDF_NO_OBJECT_ATTRIBUTES, &m_HistoryLock);
        if (!NT_SUCCESS(status))
        {
            TraceError("ACT %!FUNC! WdfWaitLockCreate failed %!STATUS!", status);
        }
    }

    // Create timer object for polling sensor samples
    if (NT_SUCCESS(status))
    {
        WDF_OBJECT_ATTRIBUTES timerAttributes = {};
        WDF_TIMER_CONFIG timerConfig = {};

        WDF_TIMER_CONFIG_INIT(&timerConfig, ActivityDevice::OnTimerExpire);
        WDF_OBJECT_ATTRIBUTES_INIT(&timerAttributes);
        timerAttributes.ParentObject = sensorInstance;
        timerAttributes.ExecutionLevel = WdfExecutionLevelPassive;

        status = WdfTimerCreate(&timerConfig, &timerAttributes, &m_Timer);
        if (!NT_SUCCESS(status))
        {
            TraceError("ACT %!FUNC! WdfTimerCreate failed %!STATUS!", status);
        }
    }

    // Create timer object for keeping history
    if (NT_SUCCESS(status))
    {
        WDF_OBJECT_ATTRIBUTES timerAttributes = {};
        WDF_TIMER_CONFIG timerConfig = {};

        WDF_TIMER_CONFIG_INIT(&timerConfig, ActivityDevice::OnHistoryTimerExpire);
        WDF_OBJECT_ATTRIBUTES_INIT(&timerAttributes);
        timerAttributes.ParentObject = sensorInstance;
        timerAttributes.ExecutionLevel = WdfExecutionLevelPassive;

        status = WdfTimerCreate(&timerConfig, &timerAttributes, &m_HistoryTimer);
        if (!NT_SUCCESS(status))
        {
            TraceError("ACT %!FUNC! WdfTimerCreate for history failed %!STATUS!", status);
        }
    }

    // Last available data
    if (NT_SUCCESS(status))
    {
        // Allocate a buffer for max state count. 7 States and 1 timestamp, each 
        // state has activity  and confidence. The actual size will be adjusted when 
        // data is ready to be pushed to clx.
        const ULONG size = SENSOR_COLLECTION_LIST_SIZE(Act_Max_State_Count * 2 + 1);
        WDF_OBJECT_ATTRIBUTES memoryAttributes = {};
        WDFMEMORY memoryHandle = NULL;

        WDF_OBJECT_ATTRIBUTES_INIT(&memoryAttributes);
        memoryAttributes.ParentObject = sensorInstance;
        status = WdfMemoryCreate(&memoryAttributes, 
            PagedPool, 
            SENSOR_POOL_TAG_ACTIVITY, 
            size, 
            &memoryHandle, 
            reinterpret_cast<PVOID*>(&m_pLastSample));
        if (!NT_SUCCESS(status) || nullptr == m_pLastSample)
        {
            TraceError("ACT %!FUNC! WdfMemoryCreate failed %!STATUS!", status);
        }
        else
        {
            FILETIME time = {};
            SENSOR_COLLECTION_LIST_INIT(m_pLastSample, size);
            m_pLastSample->Count = Act_Max_State_Count * 2 + 1;
            m_pLastSample->List[ACTIVITY_DATA_TIMESTAMP].Key = PKEY_SensorData_Timestamp;
            InitPropVariantFromFileTime(&time, &(m_pLastSample->List[ACTIVITY_DATA_TIMESTAMP].Value));
            for (ULONG Count = 1; Count < Act_Max_State_Count * 2 + 1; Count += 2)
            {
                m_pLastSample->List[Count].Key = PKEY_SensorData_CurrentActivityState;
                InitPropVariantFromUInt32(ActivityState_Stationary, &(m_pLastSample->List[Count].Value));
                m_pLastSample->List[Count + 1].Key = PKEY_SensorData_CurrentActivityStateConfidence_Percentage;
                InitPropVariantFromUInt16(100, &(m_pLastSample->List[Count + 1].Value));
            }
        }
    }

    // Filtered data
    if (NT_SUCCESS(status) && nullptr != m_pLastSample && 0 != m_pLastSample->AllocatedSizeInBytes)
    {
        WDF_OBJECT_ATTRIBUTES memoryAttributes = {};
        WDFMEMORY memoryHandle = NULL;

        WDF_OBJECT_ATTRIBUTES_INIT(&memoryAttributes);
        memoryAttributes.ParentObject = sensorInstance;
        status = WdfMemoryCreate(&memoryAttributes,
            PagedPool,
            SENSOR_POOL_TAG_ACTIVITY,
            m_pLastSample->AllocatedSizeInBytes,
            &memoryHandle,
            reinterpret_cast<PVOID*>(&m_pFilteredSample));
        if (!NT_SUCCESS(status) || nullptr == m_pFilteredSample)
        {
            TraceError("ACT %!FUNC! WdfMemoryCreate failed %!STATUS!", status);
        }
        else
        {
            // It's safe to memcpy because there is no embedded pointer
            memcpy_s(m_pFilteredSample, m_pLastSample->AllocatedSizeInBytes, m_pLastSample, m_pLastSample->AllocatedSizeInBytes);
        }
    }

    // Get the Marshalled size for a single history record
    if (NT_SUCCESS(status))
    {
        // Set the count to 3, as the History Record contains information about only 
        // the most probable activity (unlike the Activity Data that can represent multiple activities)
        // { Timestamp, ActivityState, Confidence}
        m_pFilteredSample->Count = 3;
        // History Retrieval is not WOW64 compatible and hence will not involve 
        // serializing the collections list. Should Use 
        // CollectionsListGetMarshalledSizeWithoutSerialization  instead of 
        // CollectionsListGetMarshalledSize when dealing with History Collection list.
        m_HistoryMarshalledRecordSize = CollectionsListGetMarshalledSizeWithoutSerialization(m_pFilteredSample);
    }

    // Sensor Properties. This must be called after setting up m_pLastSample and m_HistoryMarshalledRecordSize
    if (NT_SUCCESS(status))
    {
        status = InitializeSensorProperties();
    }

    // Sensor Enumeration Properties.
    if (NT_SUCCESS(status))
    {
        status = InitializeEnumerationProperties();
    }

    // Supported Data-Fields
    if (NT_SUCCESS(status))
    {
        status = InitializeSupportedDataFields();
    }

    // Data field properties
    if (NT_SUCCESS(status))
    {
        status = InitializeDataFieldProperties();
    }

    // Set default threshold
    if (NT_SUCCESS(status))
    {
        const ULONG size = SENSOR_COLLECTION_LIST_SIZE(ACTIVITY_THRESHOLD_COUNT);
        WDF_OBJECT_ATTRIBUTES memoryAttributes = {};
        WDFMEMORY memoryHandle = NULL;

        WDF_OBJECT_ATTRIBUTES_INIT(&memoryAttributes);
        memoryAttributes.ParentObject = sensorInstance;
        status = WdfMemoryCreate(&memoryAttributes,
            PagedPool,
            SENSOR_POOL_TAG_ACTIVITY,
            size,
            &memoryHandle,
            reinterpret_cast<PVOID*>(&m_pThresholds));
        if (!NT_SUCCESS(status) || nullptr == m_pThresholds)
        {
            TraceError("ACT %!FUNC! WdfMemoryCreate failed %!STATUS!", status);
        }
        else
        {
            SENSOR_COLLECTION_LIST_INIT(m_pThresholds, size);
            m_pThresholds->Count = ACTIVITY_THRESHOLD_COUNT;

            m_pThresholds->List[ACTIVITY_THRESHOLD_SUBSCRIBED_STATES].Key = PKEY_SensorData_SubscribedActivityStates;
            InitPropVariantFromUInt32(Act_Default_SubscribedStates,
                &(m_pThresholds->List[ACTIVITY_THRESHOLD_SUBSCRIBED_STATES].Value));

            m_pThresholds->List[ACTIVITY_THRESHOLD_STREAMING].Key = PKEY_SensorData_ActivityStream;
            InitPropVariantFromBoolean(Act_Default_Streaming,
                &(m_pThresholds->List[ACTIVITY_THRESHOLD_STREAMING].Value));

            m_pThresholds->List[ACTIVITY_THRESHOLD_CONFIDENCE].Key = PKEY_SensorData_ConfidenceThreshold_Percentage;
            InitPropVariantFromUInt16(Act_Default_ConfidenceThreshold_Percentage,
                &(m_pThresholds->List[ACTIVITY_THRESHOLD_CONFIDENCE].Value));
        }
    }

    // Initialize history buffer
    if (NT_SUCCESS(status))
    {
        const ULONG size = sizeof(ActivitySample) * m_HistorySizeInRecords;
        WDF_OBJECT_ATTRIBUTES memoryAttributes = {};
        WDFMEMORY memoryHandle = NULL;

        WDF_OBJECT_ATTRIBUTES_INIT(&memoryAttributes);
        memoryAttributes.ParentObject = sensorInstance;
        status = WdfMemoryCreate(&memoryAttributes,
            PagedPool,
            SENSOR_POOL_TAG_ACTIVITY,
            size,
            &memoryHandle,
            reinterpret_cast<PVOID*>(&(m_History.pData)));
        if (!NT_SUCCESS(status) || nullptr == m_History.pData)
        {
            TraceError("ACT %!FUNC! WdfMemoryCreate failed %!STATUS!", status);
        }
    }

    // Create event for signaling the history retrieval thread to exit
    if (NT_SUCCESS(status))
    {
        m_ExitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
        if (NULL == m_ExitEvent || INVALID_HANDLE_VALUE == m_ExitEvent)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
            TraceError("ACT %!FUNC! Failed to create an event %!STATUS!", status);
        }
    }

    SENSOR_FunctionExit(status);
    return status;
}
	void write(elem_t* dest, size_t dest_size, const elem_t* src, size_t max_count)
	{
		memcpy_s(dest, dest_size, src, max_count);
		write_pos += max_count;
		total_size += max_count;
	}
Beispiel #13
0
inline RETCODE RecordFileScan::OpenScan (const RecordFilePtr & fileHandle, AttrType attrType, size_t attrLength, size_t attrOffset, CompOp compOp, void * value) {
	
	if ( _scanInfo.state == Open )
		return RETCODE::INVALIDSCAN;

	_recFile = fileHandle;

	if ( fileHandle == nullptr || !fileHandle->isValidRecordFile ( ) )
		return RETCODE::INVALIDPAGEFILE;

	RecordFile::RecordFileHeader header;

	_recFile->GetHeader (header);

	if ( value != nullptr ) {			// has condition

		if ( attrType != AttrType::INT && attrType != AttrType::FLOAT && attrType != AttrType::STRING )
			return INVALIDSCAN;

		if ( attrOffset + attrLength > header.recordSize || attrOffset < 0 )
			return RETCODE::INVALIDSCAN;

		switch ( compOp ) {
		case EQ_OP:
			_comp = CompMethod::equal;
			break;
		case LT_OP:
			_comp = CompMethod::less_than;
			break;
		case GT_OP:
			_comp = CompMethod::greater_than;
			break;
		case LE_OP:
			_comp = CompMethod::less_than_or_eq_to;
			break;
		case GE_OP:
			_comp = CompMethod::greater_than_or_eq_to;
			break;
		case NE_OP:
			_comp = CompMethod::not_equal;
			break;
		case NO_OP:
			_comp = nullptr;
			break;
		default:
			return RETCODE::INVALIDSCAN;
			break;
		}

		_attrType = attrType;

		_attrLength = attrLength;

		_attrOffset = attrOffset;

		if ( ( attrType == AttrType::INT || attrType == AttrType::FLOAT ) && attrLength != 4 )
			return RETCODE::INVALIDSCAN;

		_attrValue = shared_ptr<void> (reinterpret_cast< void* >( new char[attrLength] ( ) ));

		memcpy_s (_attrValue.get ( ), attrLength, value, attrLength);

	} 

	// initialize the status
	_scanInfo.state = Open;
	_scanInfo.recordsCount = header.recordSize;
	_scanInfo.scanedPage = BeginPage;
	_scanInfo.scanedSlot = 0;
	
	_curPage = nullptr;

	return RETCODE::COMPLETE;
}
Beispiel #14
0
/* define the normal version */
size_t __cdecl _fread_nolock_s(
    void *buffer,
    size_t bufferSize,
    size_t elementSize,
    size_t num,
    FILE *stream
)
{
    char *data;                     /* point inside the destination buffer to where we need to copy the read chars */
    size_t dataSize;                /* space left in the destionation buffer (in bytes) */
    size_t total;                   /* total bytes to read */
    size_t count;                   /* num bytes left to read */
    unsigned streambufsize;         /* size of stream buffer */
    unsigned nbytes;                /* how much to read now */
    unsigned nread;                 /* how much we did read */
    int c;                          /* a temp char */

    /* initialize local vars */
    data = buffer;
    dataSize = bufferSize;

    if (elementSize == 0 || num == 0)
    {
        return 0;
    }


    count = total = elementSize * num;

    if (anybuf(stream))
    {
        /* already has buffer, use its size */
        streambufsize = stream->_bufsiz;
    }
    else
    {
        /* assume will get _INTERNAL_BUFSIZ buffer */
        streambufsize = _INTERNAL_BUFSIZ;
    }

    /* here is the main loop -- we go through here until we're done */
    while (count != 0) {
        /* if the buffer exists and has characters, copy them to user
            buffer */
        if (anybuf(stream) && stream->_cnt != 0)
        {
            if(stream->_cnt < 0)
            {
                _ASSERTE(("Inconsistent Stream Count. Flush between consecutive read and write", stream->_cnt >= 0));
                stream->_flag |= _IOERR;
                return (total - count) / elementSize;
            }

            /* how much do we want? */
            nbytes = (count < (size_t)stream->_cnt) ? (unsigned)count : stream->_cnt;
            if (nbytes > dataSize)
            {
                if (bufferSize != SIZE_MAX)
                {
                    memset(buffer, _BUFFER_FILL_PATTERN, bufferSize);
                }
                _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0)
            }
            memcpy_s(data, dataSize, stream->_ptr, nbytes);

            /* update stream and amt of data read */
            count -= nbytes;
            stream->_cnt -= nbytes;
            stream->_ptr += nbytes;
            data += nbytes;
            dataSize -= nbytes;
        }
        else if (count >= streambufsize)
        {
            /* If we have more than streambufsize chars to read, get data
                by calling read with an integral number of bufsiz
                blocks.  Note that if the stream is text mode, read
                will return less chars than we ordered. */

            /* calc chars to read -- (count/streambufsize) * streambufsize */
            nbytes = ( streambufsize ? (unsigned)(count - count % streambufsize) :
                        (unsigned)count );
            if (nbytes > dataSize)
            {
                if (bufferSize != SIZE_MAX)
                {
                    memset(buffer, _BUFFER_FILL_PATTERN, bufferSize);
                }
                _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0)
            }

            nread = _read(_fileno(stream), data, nbytes);
            if (nread == 0) {
                    /* end of file -- out of here */
                    stream->_flag |= _IOEOF;
                    return (total - count) / elementSize;
            }
            else if (nread == (unsigned)-1) {
                    /* error -- out of here */
                    stream->_flag |= _IOERR;
                    return (total - count) / elementSize;
            }

            /* update count and data to reflect read */
            count -= nread;
            data += nread;
            dataSize -= nread;
        }
	//-----------------------------------------------------------------------------
	void GGUIDXRenderManager::AddRnederUnit(const stRenderUnit& theRenderUnit)
	{
		//检查数组容量是否足够。
		if (m_nVertexContentIndexEnd+4 >= m_nVertexContentCapacity)
		{
			//容器空间不够了,则把容器空间扩大到原来的2倍。
			SoUInt sizeOfOldArray = (SoUInt)sizeof(stVertexContent) * m_nVertexContentCapacity;
			m_nVertexContentCapacity *= 2;
			stVertexContent* pNewArray = new stVertexContent[m_nVertexContentCapacity];
			SoUInt sizeOfNewArray = (SoUInt)sizeof(stVertexContent) * m_nVertexContentCapacity;
			memset(pNewArray, 0, sizeOfNewArray);
			memcpy_s(pNewArray, sizeOfNewArray, m_arrayVertexContent, sizeOfOldArray);
			SAFE_DELETE_ARRAY(m_arrayVertexContent);
			m_arrayVertexContent = pNewArray;
			//同步的扩充顶点缓冲区和索引缓冲区。
			CreateDXVertexBuffer(m_nVertexContentCapacity);
			CreateDXIndexBuffer(m_nVertexContentCapacity / 2);
		}
		//
		SoFloat fLeft = theRenderUnit.fPositionX;
		SoFloat fRight = fLeft + theRenderUnit.fWidth;
		SoFloat fTop = theRenderUnit.fPositionY;
		SoFloat fBottom = fTop + theRenderUnit.fHeight;
		SoFloat fDepth = theRenderUnit.fPositionZ;
		SoUInt32 uiColor = SoMakeColorRGBA(theRenderUnit.fColorR, theRenderUnit.fColorG, theRenderUnit.fColorB, theRenderUnit.fColorA);
		SoFloat fUVLeft = 0.0f;
		SoFloat fUVRight = 0.0f;
		SoFloat fUVTop = 0.0f;
		SoFloat fUVBottom = 0.0f;
		//
		//s_pTargetImageset没有放到头文件中作为成员变量,是因为不想为了字节对齐而
		//考虑s_pTargetImageset在成员列表中的排序问题。
		//这样做有缺陷,如果在一系列的AddRnederUnit()调用过程中做了删除Imageset的操作,
		//s_pTargetImageset有可能变成野指针。
		static GGUIImageset* s_pTargetImageset = NULL;
		ImagesetID destImagesetID = theRenderUnit.theImagesetID;
		if (m_theTargetImagesetID != destImagesetID)
		{
			m_theTargetImagesetID = destImagesetID;
			s_pTargetImageset = GGUIImagesetManager::GetInstance()->GetImageset(destImagesetID);
			m_theTargetDXTextureID = s_pTargetImageset->GetDXTextureID();
		}
		if (s_pTargetImageset)
		{
			const GGUIRect* pRect = s_pTargetImageset->GetImageRect(theRenderUnit.theImageRectID);
			if (pRect)
			{
				fUVLeft = pRect->m_fLeft;
				fUVRight = pRect->m_fRight;
				fUVTop = pRect->m_fTop;
				fUVBottom = pRect->m_fBottom;
			}
		}
		//
		m_arrayVertexContent[m_nVertexContentIndexEnd].fX = fLeft;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fY = fTop;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fZ = fDepth;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fRHW = 1.0f;
		m_arrayVertexContent[m_nVertexContentIndexEnd].uiColor = uiColor;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fCoordX = fUVLeft;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fCoordY = fUVTop;
		++m_nVertexContentIndexEnd;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fX = fRight;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fY = fTop;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fZ = fDepth;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fRHW = 1.0f;
		m_arrayVertexContent[m_nVertexContentIndexEnd].uiColor = uiColor;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fCoordX = fUVRight;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fCoordY = fUVTop;
		++m_nVertexContentIndexEnd;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fX = fRight;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fY = fBottom;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fZ = fDepth;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fRHW = 1.0f;
		m_arrayVertexContent[m_nVertexContentIndexEnd].uiColor = uiColor;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fCoordX = fUVRight;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fCoordY = fUVBottom;
		++m_nVertexContentIndexEnd;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fX = fLeft;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fY = fBottom;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fZ = fDepth;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fRHW = 1.0f;
		m_arrayVertexContent[m_nVertexContentIndexEnd].uiColor = uiColor;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fCoordX = fUVLeft;
		m_arrayVertexContent[m_nVertexContentIndexEnd].fCoordY = fUVBottom;
		++m_nVertexContentIndexEnd;
	}
Beispiel #16
0
// 函数说明:	合并壳与被加壳程序
void CPE::MergeBuf(LPBYTE pFileBuf, DWORD pFileBufSize,
	LPBYTE pShellBuf, DWORD pShellBufSize, 
	LPBYTE& pFinalBuf, DWORD& pFinalBufSize)
{
	//获取最后一个区段的信息
	PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pFileBuf;
	PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(pFileBuf + pDosHeader->e_lfanew);
	PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(pNtHeader);
	PIMAGE_SECTION_HEADER pLastSection =
		&pSectionHeader[pNtHeader->FileHeader.NumberOfSections - 1];

	//1.修改区段数量
	pNtHeader->FileHeader.NumberOfSections += 1;

	//2.编辑区段表头结构体信息
	PIMAGE_SECTION_HEADER AddSectionHeader =
		&pSectionHeader[pNtHeader->FileHeader.NumberOfSections - 1];
	memcpy_s(AddSectionHeader->Name, 8, ".FKBUG", 6);

	//VOffset(1000对齐)
	DWORD dwTemp = 0;
	dwTemp = (pLastSection->Misc.VirtualSize / m_dwMemAlign) * m_dwMemAlign;
	if (pLastSection->Misc.VirtualSize % m_dwMemAlign)
	{
		dwTemp += m_dwMemAlign;
	}
	AddSectionHeader->VirtualAddress = pLastSection->VirtualAddress + dwTemp;

	//Vsize(实际添加的大小)
	AddSectionHeader->Misc.VirtualSize = pShellBufSize;

	//ROffset(旧文件的末尾)
	AddSectionHeader->PointerToRawData = pFileBufSize;

	//RSize(200对齐)
	dwTemp = (pShellBufSize / m_dwFileAlign) * m_dwFileAlign;
	if (pShellBufSize % m_dwFileAlign)
	{
		dwTemp += m_dwFileAlign;
	}
	AddSectionHeader->SizeOfRawData = dwTemp;

	//标志
	AddSectionHeader->Characteristics = 0XE0000040;

	//3.修改 PE 头文件大小属性,增加文件大小
	dwTemp = (pShellBufSize / m_dwMemAlign) * m_dwMemAlign;
	if (pShellBufSize % m_dwMemAlign)
	{
		dwTemp += m_dwMemAlign;
	}
	pNtHeader->OptionalHeader.SizeOfImage += dwTemp;


	//4.申请合并所需要的空间
	//4.0.计算保存IAT所用的空间大小
	DWORD dwIATSize = 0;
	dwIATSize = m_dwSizeOfModBuf + m_dwSizeOfFunBuf + m_dwNumOfIATFuns*sizeof(MYIMPORT);

	if (dwIATSize % m_dwMemAlign)
	{
		dwIATSize = (dwIATSize / m_dwMemAlign + 1)*m_dwMemAlign;
	}
	pNtHeader->OptionalHeader.SizeOfImage += dwIATSize;
	AddSectionHeader->Misc.VirtualSize += dwIATSize;
	AddSectionHeader->SizeOfRawData += dwIATSize;

	pFinalBuf = new BYTE[pFileBufSize + dwTemp + dwIATSize];
	pFinalBufSize = pFileBufSize + dwTemp + dwIATSize;
	memset(pFinalBuf, 0, pFileBufSize + dwTemp + dwIATSize);
	memcpy_s(pFinalBuf, pFileBufSize, pFileBuf, pFileBufSize);
	memcpy_s(pFinalBuf + pFileBufSize, dwTemp, pShellBuf, dwTemp);

	//拷贝IAT信息
	if (dwIATSize == 0)
	{
		return;
	}
	DWORD dwIATBaseRVA = pFileBufSize + pShellBufSize;
	m_dwIATBaseRVA = dwIATBaseRVA;

	memcpy_s(pFinalBuf + dwIATBaseRVA,
		dwIATSize, m_pMyImport, m_dwNumOfIATFuns*sizeof(MYIMPORT));

	//加密模块名
	for (DWORD i = 0; i < m_dwSizeOfModBuf; i++)
	{
		if (((char*)m_pModNameBuf)[i] != 0)
		{
			((char*)m_pModNameBuf)[i] ^= 0x15;
		}
	}

	memcpy_s(pFinalBuf + dwIATBaseRVA + m_dwNumOfIATFuns*sizeof(MYIMPORT),
		dwIATSize, m_pModNameBuf, m_dwSizeOfModBuf);

	//IAT函数名加密
	for (DWORD i = 0; i < m_dwSizeOfFunBuf; i++)
	{
		if (((char*)m_pFunNameBuf)[i] != 0)
		{
			((char*)m_pFunNameBuf)[i] ^= 0x15;
		}
	}

	memcpy_s(pFinalBuf + dwIATBaseRVA + m_dwNumOfIATFuns*sizeof(MYIMPORT)+m_dwSizeOfModBuf,
		dwIATSize, m_pFunNameBuf, m_dwSizeOfFunBuf);
}
Beispiel #17
0
	void GOAPapp::loadMaps()//for drawing
	{
		//load public shader
		m_shaderID = shaderMgr->loadShader(TEXT("Shader\\GOAP"), "PT");



		//load all the txt map

		char* mapsname[TotalMaps] = { "simulation.txt" };

		for (int i = 0; i < TotalMaps; ++i)
		{
			std::ifstream* ifs = new std::ifstream("tests\\" + std::string(mapsname[i]));
			char buffer[Map_MaxWidth];
			ifs->getline(buffer, Map_MaxWidth);
			uint w = strlen(buffer);// n
			uint h = 0;
			AstarMap* oneMap = new AstarMap(std::string(mapsname[i]));

			for (;; ++h, ifs->getline(buffer, Map_MaxWidth))
			{
				for (uint j = 0; j < w; ++j)
				{
					/*
					Start (1 NPC each)
					Money
					Wolf
					Oven
					Table (eat)
					Fur Trader
					General Store
					Pizza Hut
					*/
					vec2f texCoordInCombinedTex;
					switch (buffer[j])
					{
					case 'S'://start
						oneMap->nodesList.push_back(AstarMapNode(START, j, h, w*h + j));
						oneMap->startNode.push_back(oneMap->nodesList.size() - 1);
						botVec.push_back(new AIbot(oneMap->nodesList.size() - 1));
						botVec.back()->display = NPC1 + botVec.size() - 1;
						break;
					case 'E'://end
						ADDNODE(END)
							//oneMap->endNode = oneMap->nodesList.size()-1;
							break;
					case '.'://empty
						ADDNODE(EMPTY)
							break;
					case '/'://water
						ADDNODE(SEMIBLOCKER)
							break;
					case '#'://stone
						ADDNODE(BLOCKER)
							break;
					case 'M'://money
						ADDNODE(MONEY)
							oneMap->resource[MONEY]->push_back(Res(w*h + j, true));
						break;
					case 'W'://wolf
						ADDNODE(WOLF)
							oneMap->resource[WOLF]->push_back(Res(w*h + j, true));
						break;
					case 'O'://Oven
						ADDNODE(OVEN)
							oneMap->resource[OVEN]->push_back(Res(w*h + j));
						break;
					case 'T'://table , means eat
						ADDNODE(TABLE)
							oneMap->resource[TABLE]->push_back(Res(w*h + j));
						break;
					case 'F'://Fur Trader
						ADDNODE(FURTRADER)
							oneMap->resource[FURTRADER]->push_back(Res(w*h + j));
						break;
					case 'G'://	General Store
						ADDNODE(GENERALSTORE)
							oneMap->resource[GENERALSTORE]->push_back(Res(w*h + j));
						break;
					case 'B':
						ADDNODE(BANK)
							oneMap->resource[BANK]->push_back(Res(w*h + j));
						break;
					case 'P'://	Pizza Hut						
						ADDNODE(PIZZAHUT)
							oneMap->resource[PIZZAHUT]->push_back(Res(w*h + j));
						break;
					default:
						errorMsg("Map error: can't recognize the character or this line doesn't match the width", "error!");
						break;
					}

					texCoordInCombinedTex = oneMap->getTexCoord(oneMap->nodesList.back().nodeType);

					oneMap->vertices.push_back(PT_Vertex(j, h, texCoordInCombinedTex));
					oneMap->vertices.push_back(PT_Vertex(j + 1, h, texCoordInCombinedTex + vec2f(1, 0)));
					oneMap->vertices.push_back(PT_Vertex(j + 1, h - 1, texCoordInCombinedTex + vec2f(1, 1 / TEXCOUNT)));
					oneMap->vertices.push_back(PT_Vertex(j, h - 1, texCoordInCombinedTex + vec2f(0, 1 / TEXCOUNT)));
				}

				if (ifs->eof())
				{
					ifs->close();
					delete ifs;
					break;
				}

			}



			oneMap->width = w;
			oneMap->height = h + 1;



			oneMap->renderObj.reset(new RenderObject(std::string(mapsname[i])));
			oneMap->renderObj->vbo = new PT_Vertex[oneMap->vertices.size()];
			oneMap->renderObj->VertexNum = oneMap->vertices.size();
			memcpy_s(oneMap->renderObj->vbo, oneMap->renderObj->VertexNum * sizeof(PT_Vertex), &oneMap->vertices.front(), oneMap->renderObj->VertexNum * sizeof(PT_Vertex));



			//vbo,ibo

			for (unsigned int row = 0; row < h + 1; ++row)
			{
				for (unsigned int col = 0; col < w; ++col)
				{
					unsigned int idx = 4 * (row * w + col);
					oneMap->renderObj->ibo.push_back(idx);
					oneMap->renderObj->ibo.push_back(idx + 1);
					oneMap->renderObj->ibo.push_back(idx + 2);

					oneMap->renderObj->ibo.push_back(idx);
					oneMap->renderObj->ibo.push_back(idx + 2);
					oneMap->renderObj->ibo.push_back(idx + 3);
				}
			}

			oneMap->renderObj->IndexNum = oneMap->renderObj->ibo.size();

			oneMap->renderObj.get()->vbo_id = m_pRenderer->createVBO(oneMap->renderObj->vbo, sizeof(PT_Vertex), oneMap->renderObj.get()->VertexNum, m_shaderID, "PT");
			oneMap->renderObj.get()->ibo_id = m_pRenderer->createIBO(oneMap->renderObj->ibo.data(),oneMap->renderObj->IndexNum);


			m_maps.push_back(oneMap);
		}

		initBots(m_maps[currentMapIdx]);

	}
Beispiel #18
0
// 函数说明: 加壳的时候把 IAT(导入表) 保存出来
void CPE::SaveImportTab()
{
	if (m_PEImportDir.VirtualAddress == 0)
	{
		return;
	}
	//0.获取导入表结构体指针
	PIMAGE_IMPORT_DESCRIPTOR pPEImport =
		(PIMAGE_IMPORT_DESCRIPTOR)(m_pFileBuf + m_PEImportDir.VirtualAddress);

	//1.第一遍循环确定 m_pModNameBuf 和 m_pFunNameBuf 的大小
	DWORD dwSizeOfModBuf = 0;
	DWORD dwSizeOfFunBuf = 0;
	m_dwNumOfIATFuns = 0;
	while (pPEImport->Name)
	{
		DWORD dwModNameRVA = pPEImport->Name;
		char* pModName = (char*)(m_pFileBuf + dwModNameRVA);
		dwSizeOfModBuf += (strlen(pModName) + 1);

		PIMAGE_THUNK_DATA pIAT = (PIMAGE_THUNK_DATA)(m_pFileBuf + pPEImport->FirstThunk);

		while (pIAT->u1.AddressOfData)
		{
			if (IMAGE_SNAP_BY_ORDINAL(pIAT->u1.Ordinal))
			{
				m_dwNumOfIATFuns++;
			}
			else
			{
				m_dwNumOfIATFuns++;
				DWORD dwFunNameRVA = pIAT->u1.AddressOfData;
				PIMAGE_IMPORT_BY_NAME pstcFunName = (PIMAGE_IMPORT_BY_NAME)(m_pFileBuf + dwFunNameRVA);
				dwSizeOfFunBuf += (strlen(pstcFunName->Name) + 1);
			}
			pIAT++;
		}
		pPEImport++;
	}

	//2.第二遍循环保存信息到自己定义的数据结构里边
	m_pModNameBuf = new CHAR[dwSizeOfModBuf];
	m_pFunNameBuf = new CHAR[dwSizeOfFunBuf];
	m_pMyImport = new MYIMPORT[m_dwNumOfIATFuns];
	memset(m_pModNameBuf, 0, dwSizeOfModBuf);
	memset(m_pFunNameBuf, 0, dwSizeOfFunBuf);
	memset(m_pMyImport, 0, sizeof(MYIMPORT)*m_dwNumOfIATFuns);

	pPEImport =	(PIMAGE_IMPORT_DESCRIPTOR)(m_pFileBuf + m_PEImportDir.VirtualAddress);
	DWORD TempNumOfFuns = 0;
	DWORD TempModRVA = 0;
	DWORD TempFunRVA = 0;
	while (pPEImport->Name)
	{
		DWORD dwModNameRVA = pPEImport->Name;
		char* pModName = (char*)(m_pFileBuf + dwModNameRVA);
		memcpy_s((PCHAR)m_pModNameBuf + TempModRVA, strlen(pModName) + 1, 
			pModName, strlen(pModName) + 1);

		PIMAGE_THUNK_DATA pIAT = (PIMAGE_THUNK_DATA)(m_pFileBuf + pPEImport->FirstThunk);

		while (pIAT->u1.AddressOfData)
		{
			if (IMAGE_SNAP_BY_ORDINAL(pIAT->u1.Ordinal))
			{
				//保存以序号导入方式的函数信息
				m_pMyImport[TempNumOfFuns].m_dwIATAddr = (DWORD)pIAT - (DWORD)m_pFileBuf;
				m_pMyImport[TempNumOfFuns].m_bIsOrdinal = TRUE;
				m_pMyImport[TempNumOfFuns].m_Ordinal = pIAT->u1.Ordinal & 0x7FFFFFFF;
				m_pMyImport[TempNumOfFuns].m_dwModNameRVA = TempModRVA;
			}
			else
			{
				//保存名称导入方式的函数信息
				m_pMyImport[TempNumOfFuns].m_dwIATAddr = (DWORD)pIAT - (DWORD)m_pFileBuf;

				DWORD dwFunNameRVA = pIAT->u1.AddressOfData;
				PIMAGE_IMPORT_BY_NAME pstcFunName = (PIMAGE_IMPORT_BY_NAME)(m_pFileBuf + dwFunNameRVA);
				memcpy_s((PCHAR)m_pFunNameBuf + TempFunRVA, strlen(pstcFunName->Name) + 1,
					pstcFunName->Name, strlen(pstcFunName->Name) + 1);

				m_pMyImport[TempNumOfFuns].m_dwFunNameRVA = TempFunRVA;
				m_pMyImport[TempNumOfFuns].m_dwModNameRVA = TempModRVA;
				TempFunRVA += (strlen(pstcFunName->Name) + 1);
			}
			TempNumOfFuns++;
			pIAT++;
		}
		TempModRVA += (strlen(pModName) + 1);
		pPEImport++;
	}

	//逆序排列 m_pMyImport
	MYIMPORT stcTemp = { 0 };
	DWORD dwTempNum = m_dwNumOfIATFuns / 2;
	for (DWORD i = 0; i < dwTempNum; i++)
	{
		m_pMyImport[i];
		m_pMyImport[m_dwNumOfIATFuns - i - 1];
		memcpy_s(&stcTemp, sizeof(MYIMPORT), &m_pMyImport[i], sizeof(MYIMPORT));
		memcpy_s(&m_pMyImport[i], sizeof(MYIMPORT), &m_pMyImport[m_dwNumOfIATFuns - i - 1], sizeof(MYIMPORT));
		memcpy_s(&m_pMyImport[m_dwNumOfIATFuns - i - 1], sizeof(MYIMPORT), &stcTemp, sizeof(MYIMPORT));
	}

	//保存信息
	m_dwSizeOfModBuf = dwSizeOfModBuf;
	m_dwSizeOfFunBuf = dwSizeOfFunBuf;
}
pse_op_error_t sqlite_read_db(uint32_t leaf_id, pse_vmc_hash_tree_cache_t* cache)
{
    PROFILE_START("sqlite_read_db");
   
    int            rc;
    pse_op_error_t ret = OP_SUCCESS;
    sqlite3_stmt*  stat = NULL;
    char           sql_sentence[1024] = {0};
    int            result;
    uint32_t       node_id;
    const void*    ptr_blob_content;
    uint32_t       blob_len;
    uint32_t       record_count = 0;
    uint32_t       read_list_array[INIT_TOTAL_NODE_NUMBER_FOR_READING] = {0};
    sqlite3        *db = NULL;
    uint8_t*       node_ptr = NULL;
    uint32_t       child_node_id = leaf_id;
    uint32_t       internal_index = 0;
    uint32_t       count = 0;

    if( !cache)
    {
        PROFILE_END("sqlite_read_db");
        return OP_ERROR_INVALID_PARAMETER;
    }

    if(leaf_id < INIT_MIN_LEAF_NODE_ID || leaf_id > INIT_MAX_LEAF_NODE_ID)
    {
        PROFILE_END("sqlite_read_db");
        return OP_ERROR_INVALID_PARAMETER;
    }

    ret = sqlite_open_db(&db);
    if(OP_SUCCESS != ret) 
    {
        pse_vmc_db_state = PSE_VMC_DB_STATE_DOWN;
        PROFILE_END("sqlite_read_db");
        return ret;
    }

    // layout of read_list_array is : Leaf Node ID + ancestor Node IDs + Brother Node IDs.
    find_all_related_node_index(leaf_id, read_list_array);

    // prepare sql statement
    if (_snprintf_s(sql_sentence, sizeof(sql_sentence), "select * from HASH_TREE_NODE_TABLE where ID IN (") < 0)
    {
        ret = OP_ERROR_INTERNAL;
        goto clean_up;
    }
    
    for(uint32_t index=0; index < INIT_TOTAL_NODE_NUMBER_FOR_READING; index++)
    {
        char id[10];

        if (_snprintf_s(id, sizeof(id), "%u", read_list_array[index]) < 0) 
        {
            ret = OP_ERROR_INTERNAL;
            goto clean_up;
        }

        if (strncat_s(sql_sentence, sizeof(sql_sentence), id, strnlen_s(id, 10)) != 0)
        {
            ret = OP_ERROR_INTERNAL;
            goto clean_up;
        }

        if (index != INIT_TOTAL_NODE_NUMBER_FOR_READING - 1)
        {
            if (strncat_s(sql_sentence, sizeof(sql_sentence), ",", 1) != 0)
            {
                ret = OP_ERROR_INTERNAL;
                goto clean_up;
            }
        }
    }
    if (strcat_s(sql_sentence, sizeof(sql_sentence), ") order by ID desc") != 0)
    {
        ret = OP_ERROR_INTERNAL;
        goto clean_up;
    }

    // prepare sql statement
    rc = sqlite3_prepare_v2(db, sql_sentence, -1, &stat, 0);
    EXIT_IFNOT_SQLITE_OK(rc, clean_up)

    // query
    // the result set are sorted, from leaf to up layers
    while ((result = sqlite3_step(stat)) == SQLITE_ROW)
    {
        // to calculate number of records returned 
        record_count++;

        node_id = sqlite3_column_int(stat, 0);
        ptr_blob_content = sqlite3_column_blob(stat, 1);
        if(!ptr_blob_content)
        {
            ret = OP_ERROR_INVALID_VMC_DB;
            goto clean_up;
        }
        blob_len = sqlite3_column_bytes(stat, 1);

        if(1 == node_id)
        {
            assert(0);
            ret = OP_ERROR_INVALID_VMC_DB;
            goto clean_up;
        }
        else if(INIT_MIN_LEAF_NODE_ID <= node_id)
        {
            // node_id has already been checked and 
            // it will not exceed INIT_MAX_LEAF_NODE_ID
            assert(node_id <= INIT_MAX_LEAF_NODE_ID);

            // leaf node
            if(blob_len != LEAF_NODE_SIZE)
            {
                ret = OP_ERROR_INVALID_VMC_DB;
                goto clean_up;
            }

            if (node_id == leaf_id)
            {
                cache->self.node_id = node_id;
                node_ptr = (uint8_t*)&cache->self.leaf;
            }
            else
            {
                cache->brother.node_id = node_id;
                node_ptr = (uint8_t*)&cache->brother.leaf;
            }
        }
        else 
        {
            assert(node_id <= INIT_MAX_LEAF_NODE_ID);

            // internal nodes
            if(blob_len != INTERNAL_NODE_SIZE)
            {
                ret = OP_ERROR_INVALID_VMC_DB;
                goto clean_up;
            }

            if (node_id == child_node_id / 2)
            {
                // this is ancestor node
                node_ptr = (uint8_t*)&cache->ancestors[internal_index].internal;
                cache->ancestors[internal_index].node_id = node_id;
            }
            else 
            {
                // this is brother of ancestors
                node_ptr = (uint8_t*)&cache->brother_of_ancestors[internal_index].internal;
                cache->brother_of_ancestors[internal_index].node_id = node_id;
            }

            count++;
            if (count == 2)
            {
                // internal nodes are arranged as pairs, one is ancestor, another is the brother of the ancestor
                count = 0;
                internal_index++;   // go up a level
                child_node_id = node_id; // now current node becomes child
            }
        }

        // copy blob data to output buffer
        if(0 != memcpy_s(node_ptr, 
                        blob_len, 
                        ptr_blob_content, 
                        blob_len))
        {
            ret = OP_ERROR_INTERNAL;
            goto clean_up;
        }
    }

    if (record_count != INIT_TOTAL_NODE_NUMBER_FOR_READING)
    {
        ret = OP_ERROR_INVALID_VMC_DB;
        goto clean_up;
    }

    if (result != SQLITE_DONE)
    {
        ret = OP_ERROR_SQLITE_INTERNAL;
    }
    
clean_up:
    assert(db != NULL);
    sqlite3_finalize(stat);
    sqlite3_close_v2(db);

    PROFILE_END("sqlite_read_db");
    return ret;
}
Beispiel #20
0
static wchar_t *
getpythonregpath(HKEY keyBase, int skipcore)
{
    HKEY newKey = 0;
    DWORD dataSize = 0;
    DWORD numKeys = 0;
    LONG rc;
    wchar_t *retval = NULL;
    WCHAR *dataBuf = NULL;
    static const WCHAR keyPrefix[] = L"Software\\Python\\PythonCore\\";
    static const WCHAR keySuffix[] = L"\\PythonPath";
    size_t versionLen, keyBufLen;
    DWORD index;
    WCHAR *keyBuf = NULL;
    WCHAR *keyBufPtr;
    WCHAR **ppPaths = NULL;

    /* Tried to use sysget("winver") but here is too early :-( */
    versionLen = strlen(PyWin_DLLVersionString);
    /* Space for all the chars, plus one \0 */
    keyBufLen = sizeof(keyPrefix) +
                sizeof(WCHAR)*(versionLen-1) +
                sizeof(keySuffix);
    keyBuf = keyBufPtr = PyMem_RawMalloc(keyBufLen);
    if (keyBuf==NULL) goto done;

    memcpy_s(keyBufPtr, keyBufLen, keyPrefix, sizeof(keyPrefix)-sizeof(WCHAR));
    keyBufPtr += Py_ARRAY_LENGTH(keyPrefix) - 1;
    mbstowcs(keyBufPtr, PyWin_DLLVersionString, versionLen);
    keyBufPtr += versionLen;
    /* NULL comes with this one! */
    memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
    /* Open the root Python key */
    rc=RegOpenKeyExW(keyBase,
                    keyBuf, /* subkey */
            0, /* reserved */
            KEY_READ,
            &newKey);
    if (rc!=ERROR_SUCCESS) goto done;
    /* Find out how big our core buffer is, and how many subkeys we have */
    rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
                    NULL, NULL, &dataSize, NULL, NULL);
    if (rc!=ERROR_SUCCESS) goto done;
    if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
    /* Allocate a temp array of char buffers, so we only need to loop
       reading the registry once
    */
    ppPaths = PyMem_RawMalloc( sizeof(WCHAR *) * numKeys );
    if (ppPaths==NULL) goto done;
    memset(ppPaths, 0, sizeof(WCHAR *) * numKeys);
    /* Loop over all subkeys, allocating a temp sub-buffer. */
    for(index=0;index<numKeys;index++) {
        WCHAR keyBuf[MAX_PATH+1];
        HKEY subKey = 0;
        DWORD reqdSize = MAX_PATH+1;
        /* Get the sub-key name */
        DWORD rc = RegEnumKeyExW(newKey, index, keyBuf, &reqdSize,
                                 NULL, NULL, NULL, NULL );
        if (rc!=ERROR_SUCCESS) goto done;
        /* Open the sub-key */
        rc=RegOpenKeyExW(newKey,
                                        keyBuf, /* subkey */
                        0, /* reserved */
                        KEY_READ,
                        &subKey);
        if (rc!=ERROR_SUCCESS) goto done;
        /* Find the value of the buffer size, malloc, then read it */
        RegQueryValueExW(subKey, NULL, 0, NULL, NULL, &reqdSize);
        if (reqdSize) {
            ppPaths[index] = PyMem_RawMalloc(reqdSize);
            if (ppPaths[index]) {
                RegQueryValueExW(subKey, NULL, 0, NULL,
                                (LPBYTE)ppPaths[index],
                                &reqdSize);
                dataSize += reqdSize + 1; /* 1 for the ";" */
            }
        }
        RegCloseKey(subKey);
    }

    /* return null if no path to return */
    if (dataSize == 0) goto done;

    /* original datasize from RegQueryInfo doesn't include the \0 */
    dataBuf = PyMem_RawMalloc((dataSize+1) * sizeof(WCHAR));
    if (dataBuf) {
        WCHAR *szCur = dataBuf;
        /* Copy our collected strings */
        for (index=0;index<numKeys;index++) {
            if (index > 0) {
                *(szCur++) = L';';
                dataSize--;
            }
            if (ppPaths[index]) {
                Py_ssize_t len = wcslen(ppPaths[index]);
                wcsncpy(szCur, ppPaths[index], len);
                szCur += len;
                assert(dataSize > (DWORD)len);
                dataSize -= (DWORD)len;
            }
        }
        if (skipcore)
            *szCur = '\0';
        else {
            /* If we have no values, we dont need a ';' */
            if (numKeys) {
                *(szCur++) = L';';
                dataSize--;
            }
            /* Now append the core path entries -
               this will include the NULL
            */
            rc = RegQueryValueExW(newKey, NULL, 0, NULL,
                                  (LPBYTE)szCur, &dataSize);
            if (rc != ERROR_SUCCESS) {
                PyMem_RawFree(dataBuf);
                goto done;
            }
        }
        /* And set the result - caller must free */
        retval = dataBuf;
    }
done:
    /* Loop freeing my temp buffers */
    if (ppPaths) {
        for(index=0; index<numKeys; index++)
            PyMem_RawFree(ppPaths[index]);
        PyMem_RawFree(ppPaths);
    }
    if (newKey)
        RegCloseKey(newKey);
    PyMem_RawFree(keyBuf);
    return retval;
}
Beispiel #21
0
void CSocketInfo::OnReceiving(bool a_ssl, const char* a_data, size_t a_len)
{
	_ASSERT(m_ssl == a_ssl);

	const size_t l_bytesReceivedBefore = m_bytesReceived;

	m_bytesReceived += a_len;

	if(m_state == MSCK_NOT_IRC)
	{
		return;
	}
	else if(m_state == MSCK_IRC_IDENTIFIED)
	{
		m_receivingBuffer.append(a_data, a_len);

		std::string::size_type l_pos;
		while((l_pos = m_receivingBuffer.find("\n")) != std::string::npos)
		{
			std::string l_line = m_receivingBuffer.substr(0, l_pos + 1);
			m_receivingBuffer.erase(0, l_pos + 1);

			INJECT_DEBUG_MSG(l_line);

			char* l_szNewLine = FiSH_DLL::_OnIncomingIRCLine(m_socket, l_line.c_str(), l_line.size());

			if(l_szNewLine)
			{
				INJECT_DEBUG_MSG("decrypted:"); INJECT_DEBUG_MSG(l_szNewLine);
				m_receivedBuffer += l_szNewLine;
				FiSH_DLL::_FreeString(l_szNewLine);
			}
			else
			{
				m_receivedBuffer += l_line;
			}
		}
	}
	else if(m_state == MSCK_HTTP_PROXY_HANDSHAKE)
	{
		if(l_bytesReceivedBefore == 0
			&& a_len >= 18
			&& memcmp("HTTP/1.", a_data, 7) == 0
			&& (strstr(a_data, "\r\n\r\n") != NULL || strstr(a_data, "\n\n") != NULL))
			// this will fail if the response is not received in one chunk...
		{
			unsigned int _dummy, l_httpCode = 0;

			if(sscanf_s(a_data, "HTTP/1.%u %u %*s", &_dummy, &l_httpCode) && l_httpCode == 200)
			{
				INJECT_DEBUG_MSG("HTTP proxy response is okay!");

				OnProxyHandshakeComplete();
				return;
			}
		}

		INJECT_DEBUG_MSG("Received bad or unrecognized HTTP proxy response.");

		m_state = MSCK_NOT_IRC;
	}
	else if(m_state == MSCK_SOCKS4_HANDSHAKE)
	{
		if(l_bytesReceivedBefore == 0 && a_len == sizeof(socks4_conn_response_t))
		{
			socks4_conn_response_t l_resp;
			memcpy_s(&l_resp, sizeof(socks4_conn_response_t), a_data, sizeof(socks4_conn_response_t));

			if(l_resp.nulbyte == 0 && l_resp.status == 0x5A)
			{
				INJECT_DEBUG_MSG("SOCKS4 proxy response is okay!");

				OnProxyHandshakeComplete();
				return;
			}
		}

		INJECT_DEBUG_MSG("Received bad or unrecognized SOCKS4 proxy response.");

		m_state = MSCK_NOT_IRC;
	}
	else if(m_state == MSCK_SOCKS5_GREETING)
	{
		if(l_bytesReceivedBefore == 0 && a_len == sizeof(socks5_greeting_response_t))
		{
			socks5_greeting_response_t l_resp;
			memcpy_s(&l_resp, sizeof(socks5_greeting_response_t), a_data, sizeof(socks5_greeting_response_t));

			if(l_resp.version == 0x05 && l_resp.auth_method != 0xFF)
			{
				m_state = MSCK_SOCKS5_AUTHENTICATION;
				return;
			}
		}

		m_state = MSCK_NOT_IRC;
	}
	else if(m_state == MSCK_SOCKS5_CONNECTION)
	{
		if(a_len > sizeof(socks5_conn_response_t))
		{
			socks5_conn_response_t l_resp;
			memcpy_s(&l_resp, sizeof(socks5_conn_response_t), a_data, sizeof(socks5_conn_response_t));

			if(l_resp.version == 0x05 && l_resp.status == 0 && l_resp.addr_type <= 0x04 && l_resp.reserved1 == 0)
			{
				INJECT_DEBUG_MSG("SOCKS5 proxy response is okay!");

				OnProxyHandshakeComplete();
				return;
			}
		}

		m_state = MSCK_NOT_IRC;
	}
	else if(m_bytesReceived > 2048) // 2 KB ought to be enough for any IRC pre-register message
	{
		INJECT_DEBUG_MSG("Received too much data without any signs for IRC activity.");

		m_state = MSCK_NOT_IRC;
	}
}
void CDlgForbidenIP::OnBnClickedButton3()
{
    //查看列表
    m_lcForbidenList.DeleteAllItems();

    vecForbiddenIP objvecForbiddenIP;

    char szSendMessage[200] = {'\0'};
    char szCommand[100]     = {'\0'};
    sprintf_s(szCommand, 100, "%s ShowForbiddenIP -a", m_pTcpClientConnect->GetKey());
    int nSendLen = (int)strlen(szCommand);

    memcpy_s(szSendMessage, 200, &nSendLen, sizeof(int));
    memcpy_s(&szSendMessage[4], 200, &szCommand, nSendLen);

    char szRecvBuff[10 * 1024] = {'\0'};
    int nRecvLen = 10 * 1024;
    bool blState = m_pTcpClientConnect->SendConsoleMessage(szSendMessage, nSendLen + sizeof(int), (char*)szRecvBuff, nRecvLen);
    if(blState == false)
    {
        MessageBox(_T(MESSAGE_SENDERROR) , _T(MESSAGE_TITLE_ERROR), MB_OK);
        return;
    }
    else
    {
        int nStrLen        = 0;
        int nPos           = 4;
        int nForbidenCount = 0;
        memcpy_s(&nForbidenCount, sizeof(int), &szRecvBuff[nPos], sizeof(int));
        nPos += sizeof(int);

        for(int i = 0; i < nForbidenCount; i++)
        {
            //开始还原数据结构
            _ForbiddenIP ForbiddenIP;

            memcpy_s(&nStrLen, sizeof(char), &szRecvBuff[nPos], sizeof(char));
            nPos += sizeof(char);

            memcpy_s(ForbiddenIP.m_szIP, nStrLen, &szRecvBuff[nPos], nStrLen);
            nPos += nStrLen;
            ForbiddenIP.m_szIP[nStrLen] = '\0';

            memcpy_s(&ForbiddenIP.m_nType, sizeof(char), &szRecvBuff[nPos], sizeof(char));
            nPos += sizeof(char);

            char szUpdateTime[30] = {'\0'};
            memcpy_s(&ForbiddenIP.m_nBeginTime, sizeof(int), &szRecvBuff[nPos], sizeof(int));
            nPos += sizeof(int);
            struct tm tmDate;
            time_t newRawTime = ForbiddenIP.m_nBeginTime;
            localtime_s(&tmDate, &newRawTime);
            sprintf_s(szUpdateTime, 30, "%04d-%02d-%02d %02d:%02d:%02d", tmDate.tm_year + 1900,
                      tmDate.tm_mon + 1,
                      tmDate.tm_mday,
                      tmDate.tm_hour,
                      tmDate.tm_min,
                      tmDate.tm_sec);

            memcpy_s(&ForbiddenIP.m_nSecond, sizeof(int), &szRecvBuff[nPos], sizeof(int));
            nPos += sizeof(int);

            //显示在桌面上
            wchar_t szForbidenIP[200]    = {'\0'};
            wchar_t szzUpdateTime[30] = {'\0'};

            int nSrcLen = MultiByteToWideChar(CP_ACP, 0, ForbiddenIP.m_szIP, -1, NULL, 0);
            int nDecLen = MultiByteToWideChar(CP_ACP, 0, ForbiddenIP.m_szIP, -1, szForbidenIP, 200);

            nSrcLen = MultiByteToWideChar(CP_ACP, 0, szUpdateTime, -1, NULL, 0);
            nDecLen = MultiByteToWideChar(CP_ACP, 0, szUpdateTime, -1, szzUpdateTime, 200);

            CString strSeconds;
            CString strType;

            if(ForbiddenIP.m_nType == 0)
            {
                strType = _T("永久封禁");
            }
            else
            {
                strType = _T("时段封禁");
            }

            strSeconds.Format(_T("%d"), ForbiddenIP.m_nSecond);

            m_lcForbidenList.InsertItem(i, szForbidenIP);
            m_lcForbidenList.SetItemText(i, 1, strType);
            m_lcForbidenList.SetItemText(i, 2, szzUpdateTime);
            m_lcForbidenList.SetItemText(i, 3, strSeconds);

            objvecForbiddenIP.push_back(ForbiddenIP);
        }
    }
}
Beispiel #23
0
// Verify message 1 then generate and return message 2 to isv.
int sp_ra_proc_msg1_req(const sample_ra_msg1_t *p_msg1,
						uint32_t msg1_size,
						ra_samp_response_header_t **pp_msg2)
{
    int ret = 0;
    ra_samp_response_header_t* p_msg2_full = NULL;
    sample_ra_msg2_t *p_msg2 = NULL;
    sample_ecc_state_handle_t ecc_state = NULL;
    sample_status_t sample_ret = SAMPLE_SUCCESS;
    bool derive_ret = false;

    if(!p_msg1 ||
       !pp_msg2 ||
       (msg1_size != sizeof(sample_ra_msg1_t)))
    {
        return -1;
    }

    // Check to see if we have registered?
    if (!g_is_sp_registered)
    {
        return SP_UNSUPPORTED_EXTENDED_EPID_GROUP;
    }

    do
    {
        // Get the sig_rl from attestation server using GID.
        // GID is Base-16 encoded of EPID GID in little-endian format.
        // In the product, the SP and attesation server uses an established channel for
        // communication.
        uint8_t* sig_rl;
        uint32_t sig_rl_size = 0;

        // The product interface uses a REST based message to get the SigRL.
        
        ret = g_sp_extended_epid_group_id->get_sigrl(p_msg1->gid, &sig_rl_size, &sig_rl);
        if(0 != ret)
        {
            fprintf(stderr, "\nError, ias_get_sigrl [%s].", __FUNCTION__);
            ret = SP_IAS_FAILED;
            break;
        }

        // Need to save the client's public ECCDH key to local storage
        if (memcpy_s(&g_sp_db.g_a, sizeof(g_sp_db.g_a), &p_msg1->g_a,
                     sizeof(p_msg1->g_a)))
        {
            fprintf(stderr, "\nError, cannot do memcpy in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        // Generate the Service providers ECCDH key pair.
        sample_ret = sample_ecc256_open_context(&ecc_state);
        if(SAMPLE_SUCCESS != sample_ret)
        {
            fprintf(stderr, "\nError, cannot get ECC context in [%s].",
                             __FUNCTION__);
            ret = -1;
            break;
        }
        sample_ec256_public_t pub_key = {{0},{0}};
        sample_ec256_private_t priv_key = {{0}};
        sample_ret = sample_ecc256_create_key_pair(&priv_key, &pub_key,
                                                   ecc_state);
        if(SAMPLE_SUCCESS != sample_ret)
        {
            fprintf(stderr, "\nError, cannot generate key pair in [%s].",
                    __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        // Need to save the SP ECCDH key pair to local storage.
        if(memcpy_s(&g_sp_db.b, sizeof(g_sp_db.b), &priv_key,sizeof(priv_key))
           || memcpy_s(&g_sp_db.g_b, sizeof(g_sp_db.g_b),
                       &pub_key,sizeof(pub_key)))
        {
            fprintf(stderr, "\nError, cannot do memcpy in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        // Generate the client/SP shared secret
        sample_ec_dh_shared_t dh_key = {{0}};
        sample_ret = sample_ecc256_compute_shared_dhkey(&priv_key,
            (sample_ec256_public_t *)&p_msg1->g_a,
            (sample_ec256_dh_shared_t *)&dh_key,
            ecc_state);
        if(SAMPLE_SUCCESS != sample_ret)
        {
            fprintf(stderr, "\nError, compute share key fail in [%s].",
                    __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

#ifdef SUPPLIED_KEY_DERIVATION

        // smk is only needed for msg2 generation.
        derive_ret = derive_key(&dh_key, SAMPLE_DERIVE_KEY_SMK_SK,
            &g_sp_db.smk_key, &g_sp_db.sk_key);
        if(derive_ret != true)
        {
            fprintf(stderr, "\nError, derive key fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        // The rest of the keys are the shared secrets for future communication.
        derive_ret = derive_key(&dh_key, SAMPLE_DERIVE_KEY_MK_VK,
            &g_sp_db.mk_key, &g_sp_db.vk_key);
        if(derive_ret != true)
        {
            fprintf(stderr, "\nError, derive key fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
#else
        // smk is only needed for msg2 generation.
        derive_ret = derive_key(&dh_key, SAMPLE_DERIVE_KEY_SMK,
                                &g_sp_db.smk_key);
        if(derive_ret != true)
        {
            fprintf(stderr, "\nError, derive key fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        // The rest of the keys are the shared secrets for future communication.
        derive_ret = derive_key(&dh_key, SAMPLE_DERIVE_KEY_MK,
                                &g_sp_db.mk_key);
        if(derive_ret != true)
        {
            fprintf(stderr, "\nError, derive key fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        derive_ret = derive_key(&dh_key, SAMPLE_DERIVE_KEY_SK,
                                &g_sp_db.sk_key);
        if(derive_ret != true)
        {
            fprintf(stderr, "\nError, derive key fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        derive_ret = derive_key(&dh_key, SAMPLE_DERIVE_KEY_VK,
                                &g_sp_db.vk_key);
        if(derive_ret != true)
        {
            fprintf(stderr, "\nError, derive key fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
#endif

        uint32_t msg2_size = sizeof(sample_ra_msg2_t) + sig_rl_size;
        p_msg2_full = (ra_samp_response_header_t*)malloc(msg2_size
                      + sizeof(ra_samp_response_header_t));
        if(!p_msg2_full)
        {
            fprintf(stderr, "\nError, out of memory in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        memset(p_msg2_full, 0, msg2_size + sizeof(ra_samp_response_header_t));
        p_msg2_full->type = TYPE_RA_MSG2;
        p_msg2_full->size = msg2_size;
        // The simulated message2 always passes.  This would need to be set
        // accordingly in a real service provider implementation.
        p_msg2_full->status[0] = 0;
        p_msg2_full->status[1] = 0;
        p_msg2 = (sample_ra_msg2_t *)p_msg2_full->body;

        // Assemble MSG2
        if(memcpy_s(&p_msg2->g_b, sizeof(p_msg2->g_b), &g_sp_db.g_b,
                    sizeof(g_sp_db.g_b)) ||
           memcpy_s(&p_msg2->spid, sizeof(sample_spid_t),
                    &g_spid, sizeof(g_spid)))
        {
            fprintf(stderr,"\nError, memcpy failed in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        // The service provider is responsible for selecting the proper EPID
        // signature type and to understand the implications of the choice!
        p_msg2->quote_type = SAMPLE_QUOTE_LINKABLE_SIGNATURE;

#ifdef SUPPLIED_KEY_DERIVATION
//isv defined key derivation function id
#define ISV_KDF_ID 2
        p_msg2->kdf_id = ISV_KDF_ID;
#else
        p_msg2->kdf_id = SAMPLE_AES_CMAC_KDF_ID;
#endif
        // Create gb_ga
        sample_ec_pub_t gb_ga[2];
        if(memcpy_s(&gb_ga[0], sizeof(gb_ga[0]), &g_sp_db.g_b,
                    sizeof(g_sp_db.g_b))
           || memcpy_s(&gb_ga[1], sizeof(gb_ga[1]), &g_sp_db.g_a,
                       sizeof(g_sp_db.g_a)))
        {
            fprintf(stderr,"\nError, memcpy failed in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        // Sign gb_ga
        sample_ret = sample_ecdsa_sign((uint8_t *)&gb_ga, sizeof(gb_ga),
                        (sample_ec256_private_t *)&g_sp_priv_key,
                        (sample_ec256_signature_t *)&p_msg2->sign_gb_ga,
                        ecc_state);
        if(SAMPLE_SUCCESS != sample_ret)
        {
            fprintf(stderr, "\nError, sign ga_gb fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        // Generate the CMACsmk for gb||SPID||TYPE||KDF_ID||Sigsp(gb,ga)
        uint8_t mac[SAMPLE_EC_MAC_SIZE] = {0};
        uint32_t cmac_size = offsetof(sample_ra_msg2_t, mac);
        sample_ret = sample_rijndael128_cmac_msg(&g_sp_db.smk_key,
            (uint8_t *)&p_msg2->g_b, cmac_size, &mac);
        if(SAMPLE_SUCCESS != sample_ret)
        {
            fprintf(stderr, "\nError, cmac fail in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        if(memcpy_s(&p_msg2->mac, sizeof(p_msg2->mac), mac, sizeof(mac)))
        {
            fprintf(stderr,"\nError, memcpy failed in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }

        if(memcpy_s(&p_msg2->sig_rl[0], sig_rl_size, sig_rl, sig_rl_size))
        {
            fprintf(stderr,"\nError, memcpy failed in [%s].", __FUNCTION__);
            ret = SP_INTERNAL_ERROR;
            break;
        }
        p_msg2->sig_rl_size = sig_rl_size;

    }while(0);

    if(ret)
    {
        *pp_msg2 = NULL;
        SAFE_FREE(p_msg2_full);
    }
    else
    {
        // Freed by the network simulator in ra_free_network_response_buffer
        *pp_msg2 = p_msg2_full;
    }

    if(ecc_state)
    {
        sample_ecc256_close_context(ecc_state);
    }

    return ret;
}
void CDlgForbidenIP::OnBnClickedButton1()
{
    //添加封禁
    char szIP[20]      = {'\0'};
    char szSeconds[20] = {'\0'};
    CString strIP;
    CString strSeconds;
    int     nType = 0;

    m_txtForbidenIP.GetWindowText(strIP);

    int nSrcLen = WideCharToMultiByte(CP_ACP, 0, strIP, strIP.GetLength(), NULL, 0, NULL, NULL);
    int nDecLen = WideCharToMultiByte(CP_ACP, 0, strIP, nSrcLen, szIP, 20, NULL,NULL);
    szIP[nDecLen] = '\0';

    nSrcLen = WideCharToMultiByte(CP_ACP, 0, strSeconds, strSeconds.GetLength(), NULL, 0, NULL, NULL);
    nDecLen = WideCharToMultiByte(CP_ACP, 0, strSeconds, nSrcLen, szSeconds, 20, NULL,NULL);
    szSeconds[nDecLen] = '\0';

    if(strlen(szIP) == 0)
    {
        MessageBox(_T(MESSAGE_INSERT_NULL) , _T(MESSAGE_TITLE_ERROR), MB_OK);
        return;
    }

    switch(GetCheckedRadioButton(IDC_RADIO1, IDC_RADIO2))
    {
    case IDC_RADIO1:
        nType = 0;
        break;
    case IDC_RADIO2:
        nType = 0;
        break;
    }

    char szSendMessage[200] = {'\0'};
    char szCommand[100]     = {'\0'};
    sprintf_s(szCommand, 100, "%s ForbiddenIP -c %s -t %d -s %s ", m_pTcpClientConnect->GetKey(), szIP, nType, szSeconds);
    int nSendLen = (int)strlen(szCommand);

    memcpy_s(szSendMessage, 200, &nSendLen, sizeof(int));
    memcpy_s(&szSendMessage[4], 200, &szCommand, nSendLen);

    char szRecvBuff[10 * 1024] = {'\0'};
    int nRecvLen = 10 * 1024;
    bool blState = m_pTcpClientConnect->SendConsoleMessage(szSendMessage, nSendLen + sizeof(int), (char*)szRecvBuff, nRecvLen);
    if(blState == false)
    {
        MessageBox(_T(MESSAGE_SENDERROR) , _T(MESSAGE_TITLE_ERROR), MB_OK);
    }
    else
    {
        int nStrLen      = 0;
        int nPos         = 4;
        int nResult      = 0;
        memcpy_s(&nResult, sizeof(int), &szRecvBuff[nPos], sizeof(int));
        nPos += sizeof(int);

        if(nResult == 0)
        {
            MessageBox(_T(MESSAGE_RESULT_SUCCESS) , _T(MESSAGE_TITLE_ERROR), MB_OK);
        }
        else
        {
            MessageBox(_T(MESSAGE_RESULT_FAIL) , _T(MESSAGE_TITLE_SUCCESS), MB_OK);
            OnBnClickedButton3();
        }
    }
}
LRESULT CBacnetInput::Fresh_Input_Item(WPARAM wParam,LPARAM lParam)
{
    int cmp_ret ;//compare if match it will 0;
    int Changed_Item = (int)wParam;
    int Changed_SubItem = (int)lParam;

    memcpy_s(&m_temp_Input_data[Changed_Item],sizeof(Str_in_point),&m_Input_data.at(Changed_Item),sizeof(Str_in_point));

    CString temp_task_info;
    CString New_CString =  m_input_list.GetItemText(Changed_Item,Changed_SubItem);
    CString cstemp_value;
    if(Changed_SubItem == INPUT_LABLE)
    {
        CString cs_temp = m_input_list.GetItemText(Changed_Item,Changed_SubItem);
        if(cs_temp.GetLength()>= STR_IN_LABEL)	//长度不能大于结构体定义的长度;
        {
            MessageBox(_T("Length can not higher than 8"),_T("Warning"));
            PostMessage(WM_REFRESH_BAC_INPUT_LIST,NULL,NULL);
            return 0;
        }
        char cTemp1[255];
        memset(cTemp1,0,255);
        WideCharToMultiByte( CP_ACP, 0, cs_temp.GetBuffer(), -1, cTemp1, 255, NULL, NULL );
        memcpy_s(m_Input_data.at(Changed_Item).label,STR_IN_LABEL,cTemp1,STR_IN_LABEL);
    }

    if(Changed_SubItem == INPUT_FULL_LABLE)
    {
        CString cs_temp = m_input_list.GetItemText(Changed_Item,Changed_SubItem);
        if(cs_temp.GetLength()>= STR_IN_DESCRIPTION_LENGTH)	//长度不能大于结构体定义的长度;
        {
            MessageBox(_T("Length can not higher than 20"),_T("Warning"));
            PostMessage(WM_REFRESH_BAC_INPUT_LIST,NULL,NULL);
            return 0;
        }

        char cTemp1[255];
        memset(cTemp1,0,255);
        WideCharToMultiByte( CP_ACP, 0, cs_temp.GetBuffer(), -1, cTemp1, 255, NULL, NULL );
        memcpy_s(m_Input_data.at(Changed_Item).description,STR_IN_DESCRIPTION_LENGTH,cTemp1,STR_IN_DESCRIPTION_LENGTH);
    }


    if(Changed_SubItem == INPUT_AUTO_MANUAL)
    {
        CString temp_cs = m_input_list.GetItemText(Changed_Item,Changed_SubItem);
        if(temp_cs.CompareNoCase(_T("Auto"))==0)
        {
            m_input_list.SetCellEnabled(Changed_Item,INPUT_VALUE,0);
            m_Input_data.at(Changed_Item).auto_manual = BAC_AUTO ;
        }
        else
        {
            m_input_list.SetCellEnabled(Changed_Item,INPUT_VALUE,1);
            m_Input_data.at(Changed_Item).auto_manual = BAC_MANUAL ;
        }
    }

    if(Changed_SubItem == INPUT_VALUE)
    {
        CString temp_cs = m_input_list.GetItemText(Changed_Item,Changed_SubItem);

        int temp_int = (int)(_wtof(temp_cs) * 1000);
        //int temp_int = _wtoi(temp_cs);
        m_Input_data.at(Changed_Item).value = temp_int;
    }

    if(Changed_SubItem == INPUT_RANGE)
    {
        CString temp_cs = m_input_list.GetItemText(Changed_Item,Changed_SubItem);
        BacnetRange dlg;
        if(temp_cs.CompareNoCase(Units_Type[UNITS_TYPE_ANALOG])==0)
        {
            bac_ranges_type = INPUT_RANGE_ANALOG_TYPE;
            dlg.DoModal();
            if(range_cancel)
            {
                PostMessage(WM_REFRESH_BAC_INPUT_LIST,Changed_Item,REFRESH_ON_ITEM);//这里调用 刷新线程重新刷新会方便一点;
                return 0;
            }
            m_Input_data.at(Changed_Item).digital_analog =  BAC_UNITS_ANALOG;
            m_Input_data.at(Changed_Item).range =  bac_range_number_choose;
            m_input_list.SetItemText(Changed_Item,INPUT_RANGE,Input_Analog_Units_Array[bac_range_number_choose]);
            m_input_list.SetItemText(Changed_Item,INPUT_UNITE,Input_List_Analog_Units[bac_range_number_choose]);

            cstemp_value.Format(_T("%d"),m_Input_data.at(Changed_Item).calibration);
            m_input_list.SetItemText(Changed_Item,INPUT_CAL,cstemp_value);


            m_input_list.SetCellEnabled(Changed_Item,INPUT_CAL,1);
            m_input_list.SetCellEnabled(Changed_Item,INPUT_UNITE,1);
            //m_input_list.SetItemText(Changed_Item,OUTPUT_100_PERSENT,_T("10"));
            //m_input_list.SetCellEnabled(Changed_Item,OUTPUT_100_PERSENT,1);

            CString cstemp_value;
            float temp_float_value;
            temp_float_value = ((float)m_Input_data.at(Changed_Item).value) / 1000;
            cstemp_value.Format(_T("%.2f"),temp_float_value);
            m_input_list.SetItemText(Changed_Item,INPUT_VALUE,cstemp_value);

            //cstemp_value.Format(_T("%d"),m_Input_data.at(Changed_Item).value);
            //m_input_list.SetItemText(Changed_Item,INPUT_VALUE,cstemp_value);
        }
        else if(temp_cs.CompareNoCase(Units_Type[UNITS_TYPE_DIGITAL])==0)
        {
            bac_range_number_choose = m_Input_data.at(Changed_Item).range;
            bac_ranges_type = INPUT_RANGE_DIGITAL_TYPE;
            dlg.DoModal();
            if(range_cancel)
            {
                PostMessage(WM_REFRESH_BAC_INPUT_LIST,Changed_Item,REFRESH_ON_ITEM);//这里调用 刷新线程重新刷新会方便一点;
                return 0;
            }
            m_Input_data.at(Changed_Item).digital_analog =  BAC_UNITS_DIGITAL;
            m_Input_data.at(Changed_Item).range =  bac_range_number_choose;
            //m_input_list.SetItemText(Changed_Item,INPUT_RANGE,INPUT_Digital_Units_Show[bac_range_number_choose]);

            m_input_list.SetItemText(Changed_Item,INPUT_CAL,_T(""));
            m_input_list.SetCellEnabled(Changed_Item,INPUT_CAL,0);
            m_input_list.SetItemText(Changed_Item,INPUT_UNITE,_T(""));
            m_input_list.SetCellEnabled(Changed_Item,INPUT_UNITE,0);

            CString temp1;
            CStringArray temparray;
            temp1 = Digital_Units_Array[bac_range_number_choose];//22 is the sizeof the array
            SplitCStringA(temparray,temp1,_T("/"));

            if(m_Input_data.at(Changed_Item).control == 1)
            {
                if((temparray.GetSize()==2)&&(!temparray.GetAt(1).IsEmpty()))
                {
                    m_input_list.SetItemText(Changed_Item,INPUT_VALUE,temparray.GetAt(1));
                }
            }
            else
            {
                if((temparray.GetSize()==2)&&(!temparray.GetAt(0).IsEmpty()))
                {
                    m_input_list.SetItemText(Changed_Item,INPUT_VALUE,temparray.GetAt(0));
                }
            }
            m_input_list.SetItemText(Changed_Item,INPUT_RANGE,temp1);


        }
        else if(temp_cs.CompareNoCase(Units_Type[UNITS_TYPE_CUSTOM])==0)
        {
            bac_ranges_type = OUTPUT_RANGE_CUSTOM_DIG_TYPE;
            //dlg.DoModal();
        }
        else
        {
            PostMessage(WM_REFRESH_BAC_INPUT_LIST,Changed_Item,REFRESH_ON_ITEM);//这里调用 刷新线程重新刷新会方便一点;
            //m_input_list.SetItemText(Changed_Item,INPUT_RANGE,temp_cs);
        }
    }


    //if(Changed_SubItem==INPUT_RANGE)
    //{
    //	CString temp_cs = m_input_list.GetItemText(Changed_Item,Changed_SubItem);
    //	if(temp_cs.CompareNoCase(_T("Not Used"))==0)
    //	{
    //		m_input_list.SetItemText(Changed_Item,INPUT_UNITE,Input_Unit[_unused]);
    //	}
    //	else if(temp_cs.CompareNoCase(_T("10K(-40->120)"))==0)
    //	{
    //		ListCtrlEx::CStrList strlist;
    //		strlist.clear();
    //		strlist.push_back(Input_Unit[degC]);
    //		//strlist.push_back(Input_Unit[degF]);
    //		m_input_list.SetCellStringList(Changed_Item, INPUT_UNITE, strlist);
    //		m_input_list.SetItemText(Changed_Item,INPUT_UNITE,Input_Unit[degC]);
    //	}
    //	else if(temp_cs.CompareNoCase(_T("I 4->20ma"))==0)
    //	{
    //		ListCtrlEx::CStrList strlist;
    //		strlist.clear();
    //		TRACE(Input_Unit[ma]);
    //		strlist.push_back(Input_Unit[ma]);
    //		m_input_list.SetCellStringList(Changed_Item, INPUT_UNITE, strlist);
    //		m_input_list.SetItemText(Changed_Item,INPUT_UNITE,Input_Unit[ma]);
    //	}
    //	else if(temp_cs.CompareNoCase(_T("V 0->10V"))==0)
    //	{
    //		ListCtrlEx::CStrList strlist;
    //		strlist.clear();
    //		TRACE(Input_Unit[Volts]);
    //		strlist.push_back(Input_Unit[Volts]);
    //		m_input_list.SetCellStringList(Changed_Item, INPUT_UNITE, strlist);
    //		m_input_list.SetItemText(Changed_Item,INPUT_UNITE,Input_Unit[Volts]);
    //	}
    //	else if(temp_cs.CompareNoCase(_T("V 0->5V"))==0)
    //	{
    //		ListCtrlEx::CStrList strlist;
    //		strlist.clear();
    //		TRACE(Input_Unit[Volts]);
    //		strlist.push_back(Input_Unit[Volts]);
    //		m_input_list.SetCellStringList(Changed_Item, INPUT_UNITE, strlist);
    //		m_input_list.SetItemText(Changed_Item,INPUT_UNITE,Input_Unit[Volts]);
    //	}
    //	else if(temp_cs.CompareNoCase(_T("V 0->24AC"))==0)
    //	{
    //		ListCtrlEx::CStrList strlist;
    //		strlist.clear();
    //		strlist.push_back(_T("ON/OFF"));
    //		m_input_list.SetCellStringList(Changed_Item, INPUT_UNITE, strlist);
    //		m_input_list.SetItemText(Changed_Item,INPUT_UNITE,_T("ON/OFF"));
    //	}
    //	else if(temp_cs.CompareNoCase(_T("TST Normal"))==0)
    //	{
    //		ListCtrlEx::CStrList strlist;
    //		strlist.clear();
    //		strlist.push_back(_T("ON/OFF"));
    //		m_input_list.SetCellStringList(Changed_Item, INPUT_UNITE, strlist);
    //		m_input_list.SetItemText(Changed_Item,INPUT_UNITE,_T("ON/OFF"));
    //	}
    //}

    if(Changed_SubItem==INPUT_CAL)
    {
        CString cs_temp=m_input_list.GetItemText(Changed_Item,INPUT_CAL);
        int cal_value = _wtoi(cs_temp);
        m_Input_data.at(Changed_Item).calibration = cal_value;
    }
    else if(Changed_SubItem==INPUT_FITLER)
    {
        CString cs_temp=m_input_list.GetItemText(Changed_Item,INPUT_FITLER);
        int  temp2 = _wtoi(cs_temp);
        m_Input_data.at(Changed_Item).filter = (int8_t)(log((double)temp2)/log((double)2));
    }
    else if(Changed_SubItem==INPUT_DECOM)
    {
        CString cs_temp = m_input_list.GetItemText(Changed_Item,INPUT_DECOM);
        int dec_index=-1;
        for (int m=0; m<(int)sizeof(Decom_Array)/sizeof(Decom_Array[0]); m++)
        {
            if(cs_temp.CompareNoCase(Decom_Array[m])==0)
            {
                dec_index = m;
                break;
            }
        }
        m_Input_data.at(Changed_Item).decom = dec_index;
    }

    cmp_ret = memcmp(&m_temp_Input_data[Changed_Item],&m_Input_data.at(Changed_Item),sizeof(Str_in_point));
    if(cmp_ret!=0)
    {
        m_input_list.SetItemBkColor(Changed_Item,Changed_SubItem,LIST_ITEM_CHANGED_BKCOLOR);
        temp_task_info.Format(_T("Write Input List Item%d .Changed to \"%s\" "),Changed_Item + 1,New_CString);
        Post_Write_Message(g_bac_instance,WRITEINPUT_T3000,Changed_Item,Changed_Item,sizeof(Str_in_point),m_input_dlg_hwnd ,temp_task_info,Changed_Item,Changed_SubItem);
    }
    //m_input_list.Invalidate();
    return 0;
}
Beispiel #26
0
int sqlite_generate_prebuild_db()
{
    sqlite3* db = NULL;
    int      rc;
    char*    errmsg = NULL;
    int      node_type;
    int      start_id, end_id;
    sqlite3_stmt* stat = NULL;
    char     sql_sentence[512] = {0};
    uint8_t* ptr_buf = NULL;
    uint32_t bufflen;
    uint8_t* ptr_precalc_node_buff = NULL;
    int      layer;

    bufflen = (INIT_MAX_HASH_TREE_LAYER-2)*sizeof(hash_tree_internal_node_t) + 
              sizeof(hash_tree_leaf_node_t);

    ptr_precalc_node_buff = (uint8_t*)malloc(bufflen);
    if(NULL == ptr_precalc_node_buff)
    {
        return -1;
    }

    memset(ptr_precalc_node_buff, 0, bufflen);

    hash_tree_internal_node_t* internal_node = (hash_tree_internal_node_t*)ptr_precalc_node_buff;
    for(int index=INIT_MAX_HASH_TREE_LAYER-3; index>=0; index--)
    {
        if(memcpy_s(internal_node->hash, 
                    sizeof(internal_node->hash), 
                    &(internal_node_hash_value_table[index][0]), 
                    HASH_VALUE_SIZE))
        {
            free(ptr_precalc_node_buff);
            return -1;
        }
        internal_node++;
    }

    if(gDb)
    {
        db = gDb;
    }
    else
    {
        rc = sqlite3_open(SQLITE_DB_FILE_NAME, &gDb);
        if( SQLITE_OK != rc )
        {
            free(ptr_precalc_node_buff);
            return rc;
        }
		db = gDb;
    }

    rc = sqlite3_exec( db, 
                       "create table VMC_QUOTA_TABLE( ID integer primary key AUTOINCREMENT, MRSIGNER char(64), COUNTER integer)", 
                       NULL,
                       NULL,
                       &errmsg );
    EXIT_IFNOT_SQLITE_OK(rc)

    rc = sqlite3_exec( db, 
                       "create table HASH_TREE_NODE_TABLE( ID integer primary key, node_content blob, USED integer, REFID integer NULL REFERENCES VMC_QUOTA_TABLE(ID))", 
                       NULL,
                       NULL,
                       &errmsg );
    EXIT_IFNOT_SQLITE_OK(rc)

    rc = sqlite3_exec( db, 
                       "create table BACKUP_TABLE( ID integer primary key, node_content blob, USED integer, REFID integer)", 
                       NULL,
                       NULL,
                       &errmsg );
    EXIT_IFNOT_SQLITE_OK(rc)

    // all nodes in the same layer have the same precalculated value
    // the merkel hash tree has 12 layers including root layer

    rc = sqlite3_exec(db, "BEGIN TRANSACTION;", NULL, NULL, NULL);
    EXIT_IFNOT_SQLITE_OK(rc)

    sprintf(sql_sentence, "insert into HASH_TREE_NODE_TABLE( ID, node_content, USED, REFID) values( ?, ?, 0, NULL)");

    rc = sqlite3_prepare_v2(db, 
                         sql_sentence, 
                         -1, 
                         &stat, 
                         0);
    EXIT_IFNOT_SQLITE_OK(rc)

    layer = INIT_MAX_HASH_TREE_LAYER - 1;
    do{
        if(INIT_MAX_HASH_TREE_LAYER - 1 == layer)
        {
            node_type = HASH_TREE_NODE_TYPE_LEAF;
        }
        else
        {
            node_type = HASH_TREE_NODE_TYPE_INTERNAL;
        }

        start_id = (int)pow((double)2,layer);
        end_id = (int)pow((double)2,layer+1) - 1;

        for(int id = start_id; id <= end_id; id++)
        {
            rc =sqlite3_bind_int(stat, 1, id);
            EXIT_IFNOT_SQLITE_OK(rc)

            switch(node_type)
            {
                case HASH_TREE_NODE_TYPE_INTERNAL:
                    ptr_buf = ptr_precalc_node_buff;
                    rc = sqlite3_bind_blob(stat,
                                           2,
                                           (hash_tree_internal_node_t*)ptr_buf + layer - 1,
                                           sizeof(hash_tree_internal_node_t),
                                           NULL
                                           );
                    break;
                case HASH_TREE_NODE_TYPE_LEAF:
                    rc = sqlite3_bind_blob(stat,
                                           2,
                                           ptr_precalc_node_buff + (INIT_MAX_HASH_TREE_LAYER-2)*sizeof(hash_tree_internal_node_t),
                                           sizeof(hash_tree_leaf_node_t),
                                           NULL
                                           );

                    break;
                default:
                    goto error;
            }
            EXIT_IFNOT_SQLITE_OK(rc)

            rc = sqlite3_step(stat);
            if(rc != SQLITE_DONE)
            {
                goto error;
            }

            rc = sqlite3_clear_bindings(stat);
            EXIT_IFNOT_SQLITE_OK(rc)

            rc = sqlite3_reset(stat);
            EXIT_IFNOT_SQLITE_OK(rc)
        }
        layer--;
        if(layer&0x1)
            sqlite3_sleep(1);
    }while(layer>0);

    rc = sqlite3_exec(db, "END TRANSACTION;", NULL, NULL, NULL);
    EXIT_IFNOT_SQLITE_OK(rc)

    rc = sqlite3_finalize(stat);
    EXIT_IFNOT_SQLITE_OK(rc)

    stat = NULL;

    sqlite3_close_v2(db);
    gDb = NULL;

    free(ptr_precalc_node_buff);
    
    return 0;
error:
    free(ptr_precalc_node_buff);
    if(db)
    {
        sqlite3_finalize(stat);
        sqlite3_exec(db, "ROLLBACK TRANSACTION;", NULL, NULL, NULL);
        sqlite3_close_v2(db);
        gDb = NULL;
    }
    return -1;
}
void CBacnetInput::OnNMClickList1(NMHDR *pNMHDR, LRESULT *pResult)
{
    LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
    // TODO: Add your control notification handler code here

    long lRow,lCol;
    m_input_list.Set_Edit(true);
    DWORD dwPos=GetMessagePos();//Get which line is click by user.Set the check box, when user enter Insert it will jump to program dialog
    CPoint point( LOWORD(dwPos), HIWORD(dwPos));
    m_input_list.ScreenToClient(&point);
    LVHITTESTINFO lvinfo;
    lvinfo.pt=point;
    lvinfo.flags=LVHT_ABOVE;
    int nItem=m_input_list.SubItemHitTest(&lvinfo);

    lRow = lvinfo.iItem;
    lCol = lvinfo.iSubItem;


    if(lRow>m_input_list.GetItemCount()) //如果点击区超过最大行号,则点击是无效的
        return;
    if(lRow<0)
        return;

    if(lCol != INPUT_VALUE)
        return;

    if(m_Input_data.at(lRow).digital_analog != BAC_UNITS_DIGITAL)
        return;

    if(m_Input_data.at(lRow).auto_manual == BAC_AUTO)	//If it is auto mode, disable to change the value.
        return;

    memcpy_s(&m_temp_Input_data[lRow],sizeof(Str_in_point),&m_Input_data.at(lRow),sizeof(Str_in_point));

    CString New_CString;
    CString temp_task_info;

    CString temp1;
    CStringArray temparray;
    if((m_Input_data.at(lRow).range < 23) &&(m_Input_data.at(lRow).range !=0))
        temp1 = Digital_Units_Array[m_Input_data.at(lRow).range];
    else
        return;
    SplitCStringA(temparray,temp1,_T("/"));

    if(m_Input_data.at(lRow).control == 0)
    {
        m_Input_data.at(lRow).control = 1;
        m_input_list.SetItemText(lRow,INPUT_VALUE,temparray.GetAt(1));
        New_CString = temparray.GetAt(1);
    }
    else
    {
        m_Input_data.at(lRow).control = 0;
        m_input_list.SetItemText(lRow,INPUT_VALUE,temparray.GetAt(0));
        New_CString = temparray.GetAt(0);
    }
#if 0
    if(m_Input_data.at(lRow).range > 11)
        temp1 = Digital_Units_Array[m_Input_data.at(lRow).range - 11];//11 is the sizeof the array
    else
        temp1 = Digital_Units_Array[m_Input_data.at(lRow).range];
    SplitCStringA(temparray,temp1,_T("/"));

    if(m_Input_data.at(lRow).range>=12)
    {

        if((temparray.GetSize()==2)&&(!temparray.GetAt(1).IsEmpty()))
        {
            m_input_list.SetItemText(lRow,INPUT_VALUE,temparray.GetAt(0));
            m_Input_data.at(lRow).range = m_Input_data.at(lRow).range - 11;
            New_CString = temparray.GetAt(0);
            m_Input_data.at(lRow).control = 0;
        }

    }
    else if(m_Input_data.at(lRow).range>=1)
    {

        if((temparray.GetSize()==2)&&(!temparray.GetAt(0).IsEmpty()))
        {
            m_input_list.SetItemText(lRow,INPUT_VALUE,temparray.GetAt(1));
            m_Input_data.at(lRow).range = m_Input_data.at(lRow).range + 11;
            New_CString = temparray.GetAt(1);
            m_Input_data.at(lRow).control = 1;
        }

    }
#endif
    m_input_list.Set_Edit(false);

    int cmp_ret = memcmp(&m_temp_Input_data[lRow],&m_Input_data.at(lRow),sizeof(Str_in_point));
    if(cmp_ret!=0)
    {
        m_input_list.SetItemBkColor(lRow,lCol,LIST_ITEM_CHANGED_BKCOLOR);
        temp_task_info.Format(_T("Write Input List Item%d .Changed to \"%s\" "),lRow + 1,New_CString);
        Post_Write_Message(g_bac_instance,WRITEINPUT_T3000,(int8_t)lRow,(int8_t)lRow,sizeof(Str_in_point),m_input_dlg_hwnd,temp_task_info,lRow,lCol);
    }



    *pResult = 0;
}
Beispiel #28
0
HRESULT CPixelShaderCompiler::InternalCompile(
    LPCSTR pSrcData,
    SIZE_T SrcDataSize,
    LPCSTR pSourceName,
    LPCSTR pEntrypoint,
    LPCSTR pProfile,
    DWORD Flags,
    IDirect3DPixelShader9** ppPixelShader,
    CString* pDisasm,
    CString* pErrMsg)
{
    if (!m_pD3DCompile) {
        return E_FAIL;
    }

    if (pDisasm && !m_pD3DDisassemble) {
        return E_FAIL;
    }

    if (ppPixelShader && !m_pD3DDev) {
        return E_FAIL;
    }

    LPCSTR pSelProfile = pProfile;
    if (!pSelProfile || *pSelProfile == '\0') {
        D3DCAPS9 caps;
        if (m_pD3DDev && m_pD3DDev->GetDeviceCaps(&caps) == D3D_OK) {
            switch (D3DSHADER_VERSION_MAJOR(caps.PixelShaderVersion)) {
                case 2:
                    if (caps.PS20Caps.NumInstructionSlots < 512) {
                        pSelProfile = "ps_2_0";
                    } else if (caps.PS20Caps.Caps > 0) {
                        pSelProfile = "ps_2_a";
                    } else {
                        pSelProfile = "ps_2_b";
                    }
                    break;
                case 3:
                    pSelProfile = "ps_3_0";
                    break;
            }
        } else {
            ASSERT(FALSE);
        }
    }

    if (!pSelProfile || *pSelProfile == '\0') {
        return E_FAIL;
    }

    LPCSTR defProfile = "MPC_HC_SHADER_PROFILE";
    LPCSTR defProfileVal;
    if (!strcmp(pSelProfile, "ps_2_0")) {
        defProfileVal = "0";
    } else if (!strcmp(pSelProfile, "ps_2_b")) {
        defProfileVal = "1";
    } else if (!strcmp(pSelProfile, "ps_2_a") || !strcmp(pSelProfile, "ps_2_sw")) {
        defProfileVal = "2";
    } else if (!strcmp(pSelProfile, "ps_3_0") || !strcmp(pSelProfile, "ps_3_sw")) {
        defProfileVal = "3";
    } else {
        defProfileVal = "-1";
    }

    if (ppPixelShader && SUCCEEDED(m_Cache.CreatePixelShader(defProfileVal, pSrcData, SrcDataSize, ppPixelShader))) {
        return S_OK;
    }

    D3D_SHADER_MACRO macros[] = { { defProfile, defProfileVal }, { 0 } };

    CComPtr<ID3DBlob> pShaderBlob, pErrorBlob;
    HRESULT hr = m_pD3DCompile(pSrcData, SrcDataSize, pSourceName, macros, nullptr, pEntrypoint,
                               pSelProfile, Flags, 0, &pShaderBlob, &pErrorBlob);

    if (pErrMsg) {
        CStringA msg;
        if (pErrorBlob) {
            auto len = pErrorBlob->GetBufferSize();
            VERIFY(memcpy_s(msg.GetBufferSetLength((int)len), len, pErrorBlob->GetBufferPointer(), len) == 0);
            msg.ReleaseBuffer((int)len);
        }
        *pErrMsg = msg;
    }

    if (FAILED(hr)) {
        return hr;
    }

    if (ppPixelShader) {
        hr = m_pD3DDev->CreatePixelShader((DWORD*)pShaderBlob->GetBufferPointer(), ppPixelShader);
        if (FAILED(hr)) {
            return hr;
        }

        m_Cache.SavePixelShader(defProfileVal, pSrcData, SrcDataSize,
                                (void*)pShaderBlob->GetBufferPointer(), pShaderBlob->GetBufferSize());
    }

    if (pDisasm) {
        CComPtr<ID3DBlob> pDisasmBlob;
        CStringA defs;
        for (auto pMacro = macros; pMacro && pMacro->Name && pMacro->Definition; pMacro++) {
            defs.Append("// #define ");
            defs.Append(pMacro->Name);
            defs.Append(" ");
            defs.Append(pMacro->Definition);
            defs.Append("\n");
        }
        hr = m_pD3DDisassemble(pShaderBlob->GetBufferPointer(), pShaderBlob->GetBufferSize(),
                               0, defs, &pDisasmBlob);
        if (SUCCEEDED(hr)) {
            CStringA disasm;
            auto len = pDisasmBlob->GetBufferSize();
            VERIFY(memcpy_s(disasm.GetBufferSetLength((int)len), len, pDisasmBlob->GetBufferPointer(), len) == 0);
            disasm.ReleaseBuffer((int)len);
            *pDisasm = disasm;
        }
    }

    return S_OK;
}
Beispiel #29
0
void CDlgWorkThreadAI::OnBnClickedButton1()
{
	//得到所有工作进程的AI配置
	m_lcWorkThreadAI.DeleteAllItems();

	char szSendMessage[200] = {'\0'};
	char szCommand[100]     = {'\0'};
	sprintf_s(szCommand, 100, "%s GetWorkThreadAI -a", m_pTcpClientConnect->GetKey());
	int nSendLen = (int)strlen(szCommand); 

	memcpy_s(szSendMessage, 200, &nSendLen, sizeof(int));
	memcpy_s(&szSendMessage[4], 200, &szCommand, nSendLen);

	char szRecvBuff[100 * 1024] = {'\0'};
	int nRecvLen = 100 * 1024;
	bool blState = m_pTcpClientConnect->SendConsoleMessage(szSendMessage, nSendLen + sizeof(int), (char*)szRecvBuff, nRecvLen);
	if(blState == false)
	{
		MessageBox(_T(MESSAGE_SENDERROR) , _T(MESSAGE_TITLE_ERROR), MB_OK);
		return;
	}
	else
	{
		int nStrLen       = 0;
		int nPos          = 0;
		int nThreadCount  = 0;
		memcpy_s(&nThreadCount, sizeof(short), &szRecvBuff[nPos], sizeof(short));
		nPos += sizeof(short);

		for(int i = 0; i < nThreadCount; i++)
		{
			int nThreadID       = 0;
			int nAI             = 0;
			int nDisposeTime    = 0;
			int nWTCheckTime    = 0;
			int nWTTimeoutCount = 0;
			int nWTStopTime     = 0;

			memcpy_s(&nThreadID, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);
			memcpy_s(&nAI, sizeof(char), &szRecvBuff[nPos], sizeof(char));
			nPos += sizeof(char);
			memcpy_s(&nDisposeTime, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);
			memcpy_s(&nWTCheckTime, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);
			memcpy_s(&nWTTimeoutCount, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);
			memcpy_s(&nWTStopTime, sizeof(int), &szRecvBuff[nPos], sizeof(int));
			nPos += sizeof(int);

			//显示出来
			CString strData;
			strData.Format(_T("%d"), nThreadID);
			m_lcWorkThreadAI.InsertItem(i, strData);
			if(nAI == 0)
			{
				strData = _T("AI关闭");
				m_lcWorkThreadAI.SetItemText(i, 1, strData);
			}
			else
			{
				strData = _T("AI运行中");
				m_lcWorkThreadAI.SetItemText(i, 1, strData);
			}
			
			strData.Format(_T("%d"), nDisposeTime);
			m_lcWorkThreadAI.SetItemText(i, 2, strData);
			strData.Format(_T("%d"), nWTCheckTime);
			m_lcWorkThreadAI.SetItemText(i, 3, strData);
			strData.Format(_T("%d"), nWTTimeoutCount);
			m_lcWorkThreadAI.SetItemText(i, 4, strData);
			strData.Format(_T("%d"), nWTStopTime);
			m_lcWorkThreadAI.SetItemText(i, 5, strData);
		}
	}
}
Beispiel #30
0
//Independent request process
bool __fastcall EnterRequestProcess(const char *OriginalSend, const size_t Length, const SOCKET_DATA LocalSocketData, const uint16_t Protocol, const bool IsLocal)
{
//Initialization(Send buffer part)
	std::shared_ptr<char> SendBuffer, RecvBuffer;
	if (Parameter.CompressionPointerMutation)
	{
		if (Parameter.CPM_PointerToAdditional)
		{
			std::shared_ptr<char> SendBufferTemp(new char[Length + 2U + sizeof(dns_record_aaaa) + sizeof(uint16_t)]());
			memset(SendBufferTemp.get(), 0, Length + 2U + sizeof(dns_record_aaaa) + sizeof(uint16_t));
			SendBufferTemp.swap(SendBuffer);
		}
		else if (Parameter.CPM_PointerToRR)
		{
			std::shared_ptr<char> SendBufferTemp(new char[Length + 2U + sizeof(uint16_t)]());
			memset(SendBufferTemp.get(), 0, Length + 2U + sizeof(uint16_t));
			SendBufferTemp.swap(SendBuffer);
		}
		else { //Pointer to header
			std::shared_ptr<char> SendBufferTemp(new char[Length + 1U + sizeof(uint16_t)]());
			memset(SendBufferTemp.get(), 0, Length + 1U + sizeof(uint16_t));
			SendBufferTemp.swap(SendBuffer);
		}
	}
	else {
		std::shared_ptr<char> SendBufferTemp(new char[Length + sizeof(uint16_t)]()); //Reserved 2 bytes for TCP header length.
		memset(SendBufferTemp.get(), 0, Length + sizeof(uint16_t));
		SendBufferTemp.swap(SendBuffer);
	}
	memcpy_s(SendBuffer.get(), Length, OriginalSend, Length);

//Initialization(Receive buffer part)
#if defined(ENABLE_LIBSODIUM)
	if (Parameter.RequestMode_Transport == REQUEST_MODE_TCP || Parameter.DNSCurve && DNSCurveParameter.DNSCurveMode == DNSCURVE_REQUEST_MODE_TCP || Protocol == IPPROTO_TCP)
#else
	if (Parameter.RequestMode_Transport == REQUEST_MODE_TCP || Protocol == IPPROTO_TCP)
#endif
	{
		std::shared_ptr<char> TCPRecvBuffer(new char[LARGE_PACKET_MAXSIZE + sizeof(uint16_t)]());
		memset(TCPRecvBuffer.get(), 0, LARGE_PACKET_MAXSIZE + sizeof(uint16_t));
		RecvBuffer.swap(TCPRecvBuffer);
	}
	else { //UDP
		std::shared_ptr<char> UDPRecvBuffer(new char[PACKET_MAXSIZE + sizeof(uint16_t)]());
		memset(UDPRecvBuffer.get(), 0, PACKET_MAXSIZE + sizeof(uint16_t));
		RecvBuffer.swap(UDPRecvBuffer);
	}

	size_t DataLength = 0;
//Local server requesting
	if ((Parameter.LocalMain || IsLocal) && 
		LocalRequestProcess(SendBuffer.get(), Length, RecvBuffer.get(), Protocol, LocalSocketData))
	{
	//Fin TCP request connection.
		if (Protocol == IPPROTO_TCP && LocalSocketData.Socket != INVALID_SOCKET)
		{
			shutdown(LocalSocketData.Socket, SD_BOTH);
			closesocket(LocalSocketData.Socket);
		}

		return true;
	}
	
	auto DNS_Header = (pdns_hdr)SendBuffer.get();
	DataLength = Length;
//Compression Pointer Mutation
	if (Parameter.CompressionPointerMutation && DNS_Header->Additional == 0)
	{
		DataLength = MakeCompressionPointerMutation(SendBuffer.get(), Length);
		if (DataLength < Length)
			DataLength = Length;
	}

//Direct Request requesting
	if (Parameter.DirectRequest > DIRECT_REQUEST_MODE_NONE && DirectRequestProcess(SendBuffer.get(), DataLength, RecvBuffer.get(), Protocol, true, LocalSocketData))
	{
	//Fin TCP request connection.
		if (Protocol == IPPROTO_TCP && LocalSocketData.Socket != INVALID_SOCKET)
		{
			shutdown(LocalSocketData.Socket, SD_BOTH);
			closesocket(LocalSocketData.Socket);
		}

		return true;
	}

//DNSCurve requesting
#if defined(ENABLE_LIBSODIUM)
	if (Parameter.DNSCurve)
	{
		if (DNSCurveParameter.IsEncryption && 
		//Send Length check
			(DataLength > DNSCurveParameter.DNSCurvePayloadSize + crypto_box_BOXZEROBYTES - (DNSCURVE_MAGIC_QUERY_LEN + crypto_box_PUBLICKEYBYTES + crypto_box_HALF_NONCEBYTES) || 
		//Receive Size check(TCP Mode)
		(Parameter.RequestMode_Transport == REQUEST_MODE_TCP || DNSCurveParameter.DNSCurveMode == DNSCURVE_REQUEST_MODE_TCP || Protocol == IPPROTO_TCP) && DNSCurveParameter.DNSCurvePayloadSize >= LARGE_PACKET_MAXSIZE && 
			crypto_box_ZEROBYTES + DNSCURVE_MAGIC_QUERY_LEN + crypto_box_PUBLICKEYBYTES + crypto_box_HALF_NONCEBYTES + DataLength >= LARGE_PACKET_MAXSIZE || 
		//Receive Size check(UDP Mode)
			Parameter.RequestMode_Transport != REQUEST_MODE_TCP && DNSCurveParameter.DNSCurveMode != DNSCURVE_REQUEST_MODE_TCP && Protocol != IPPROTO_TCP && DNSCurveParameter.DNSCurvePayloadSize >= PACKET_MAXSIZE && 
			crypto_box_ZEROBYTES + DNSCURVE_MAGIC_QUERY_LEN + crypto_box_PUBLICKEYBYTES + crypto_box_HALF_NONCEBYTES + DataLength >= PACKET_MAXSIZE))
				goto SkipDNSCurve;

	//DNSCurve requesting
		if (DNSCurveRequestProcess(SendBuffer.get(), DataLength, RecvBuffer.get(), Protocol, LocalSocketData))
			return true;

	//DNSCurve Encryption Only mode
		if (DNSCurveParameter.IsEncryptionOnly)
		{
		//Fin TCP request connection.
			if (Protocol == IPPROTO_TCP && LocalSocketData.Socket != INVALID_SOCKET)
			{
				shutdown(LocalSocketData.Socket, SD_BOTH);
				closesocket(LocalSocketData.Socket);
			}

			return true;
		}
	}
	SkipDNSCurve: 
#endif

//TCP requesting
	if ((Protocol == IPPROTO_TCP || Parameter.RequestMode_Transport == REQUEST_MODE_TCP) && 
		TCPRequestProcess(SendBuffer.get(), DataLength, RecvBuffer.get(), Protocol, LocalSocketData))
			return true;

//Direct requesting when Pcap Capture module is turn OFF.
#if defined(ENABLE_PCAP)
	if (!Parameter.PcapCapture)
	{
#endif
		DirectRequestProcess(SendBuffer.get(), DataLength, RecvBuffer.get(), Protocol, false, LocalSocketData);

	//Fin TCP request connection.
		if (Protocol == IPPROTO_TCP && LocalSocketData.Socket != INVALID_SOCKET)
		{
			shutdown(LocalSocketData.Socket, SD_BOTH);
			closesocket(LocalSocketData.Socket);
		}

		return true;
#if defined(ENABLE_PCAP)
	}

//UDP requesting
	RecvBuffer.reset();
	UDPRequestProcess(SendBuffer.get(), DataLength, LocalSocketData, Protocol);

	return true;
#endif
}