void NS_ISERVER::CLocalServer::LocalAuditUserQuit(CString strTermID, CString strIP,UINT nMemberID)
{
	NET_HEAD_MAN head = {0};
	head.Version = COM_VER;
	head.Length = sizeof TIBAAuditUserQuit;
	head.Cmd = C_MANGER_AUDITUSERQUIT;

	TIBAAuditUserQuit info = {0};

	_snprintf(info.termID, LEN_TERMID, CT2A(strTermID));
	_snprintf(info.termIP, LEN_IPADDR, CT2A(strIP));
	info.memberID=nMemberID;

	CByteArray buffer;
	buffer.SetSize(sizeof NET_HEAD_MAN + head.Length);

	memcpy(buffer.GetData(), &head, sizeof NET_HEAD_MAN);
	memcpy(buffer.GetData() + sizeof NET_HEAD_MAN, &info, sizeof TIBAAuditUserQuit);

	m_lpSocket->SendBuffer(buffer.GetData(), buffer.GetSize());

	buffer.RemoveAll();

	IBA_LOG(_T("发送实名下机信息,TermID=%s,IP=%s,MemberID=%d"),strTermID,strIP,nMemberID);
}

	void CPlugin::SetFirefoxCookie(const vector<SetFirefoxCookieParams>& vCookies, ULONG_PTR ulWindowId)
	{
		CString strEventType = _T("IEBatchSetCookie");
		CString strDetail;
		Json::Value json;
		Json::Value aCookies;
		for (size_t i = 0; i < vCookies.size(); i++)
		{
			const SetFirefoxCookieParams& param = vCookies[i];
			Json::Value cookie;
			cookie["url"] = (LPCSTR)CT2A(param.strURL, CP_UTF8);
			cookie["header"] = (LPCSTR)CT2A(param.strCookie, CP_UTF8);
			aCookies.append(cookie);
		}
		json["cookies"] = aCookies;

		if (ulWindowId)
		{
			char szWindowId[32] = { 0 };
			_ui64toa_s(ulWindowId, szWindowId, 32, 10);
			json["windowId"] = szWindowId;
		}

		strDetail = CA2T(json.toStyledString().c_str(), CP_UTF8);
		FireEvent(strEventType, strDetail);
	}

BOOL __stdcall ComDlgHistoryLog::EnumValue( LPCTSTR value_name, ULONG value_type, UCHAR* value, ULONG value_size, PVOID context )
{
    Json::Value *log_value = (Json::Value *)context;
    if (value_type == REG_BINARY) {
        if (_tcscmp(TEXT("MRUListEx"), value_name) != 0) {
            LPITEMIDLIST file_pidl = (LPITEMIDLIST)CoTaskMemAlloc(sizeof(UCHAR) + value_size);

            if (file_pidl) {
                memcpy(file_pidl, value, value_size);
                WCHAR mru_file_path[MAX_PATH] = { 0 };
                if (SHGetPathFromIDList(file_pidl, mru_file_path)) {
                    Json::Value item;
                    item["path"] = CT2A(mru_file_path).m_psz;
                    log_value->append(item);
                }
                CoTaskMemFree(file_pidl);
            }
        }
    }
    else if (value_type == REG_SZ) {
        if (_tcscmp(TEXT("MRUList"), value_name) != 0) {
            PWSTR mru_file_path = (PWSTR)value;
            Json::Value item;
            item["path"] = CT2A(mru_file_path).m_psz;
            log_value->append(item);
        }
    }
    
    return TRUE;
}

bool CWordBinaryMetadataDiscoveryWorker::PopulatePropertyLists(CWordBinaryMetadataDiscoveryWorker::WordPropertyTypes WordPropertyType, CStdString& sPropertyName, CStdString& sPropertyValue)
{
	USES_CONVERSION;
	switch(WordPropertyType)
	{
		case BUILT_IN_PROPERTY:
			if(sPropertyName.IsEmpty())
				return true;
			
			if (c_sHyperLinkBasePropertyName == std::string(CT2A(sPropertyName.c_str())) )
				sPropertyName = _T("Hyperlink base");
			else if (c_sHyperLinksPropertyName == std::string(CT2A(sPropertyName.c_str())) )
				return true;
			
			m_BuiltInPropertiesMap.insert(PropertyMapType::value_type(sPropertyName, sPropertyValue));
			m_lBuiltInPropertyCount++;
			break;

		case CUSTOM_PROPERTY:
			m_CustomPropertiesMap.insert(PropertyMapType::value_type(sPropertyName, sPropertyValue));
			m_lCustomPropertyCount++;
			break;

		case DOCUMENT_STATISTIC:
			m_DocumentStatisticsMap.insert(PropertyMapType::value_type(sPropertyName, sPropertyValue));
			m_lDocumentStatisticsCount++;
			break;

		default:
			LOG_WS_ERROR(_T("Unknown WordPropertyTypes passed as parameter"));
			return false;
	}
	return true;
}

BOOL CXMLElement::Merge(const CXMLElement* pInput, BOOL bOverwrite)
{
	if ( ! this || ! pInput ) return FALSE;
	if ( this == pInput ) return TRUE;

	TRACE( "Merging   XML: %s\n", (LPCSTR)CT2A( ToString( FALSE, FALSE ) ) );
	TRACE( "      and XML: %s\n", (LPCSTR)CT2A( pInput->ToString( FALSE, FALSE ) ) );

	if ( m_sName.CompareNoCase( pInput->m_sName ) != 0 )
	{
		TRACE( "Failed to merge XML due different schemes \"%s\" and \"%s\".\n", (LPCSTR)CT2A( m_sName ), (LPCSTR)CT2A( pInput->m_sName ) );
		return FALSE;
	}

	BOOL bChanged = FALSE;

	for ( POSITION pos = pInput->GetElementIterator(); pos; )
	{
		const CXMLElement* pElement = pInput->GetNextElement( pos );
		CXMLElement* pTarget = GetElementByName( pElement->m_sName );

		if ( pTarget == NULL )
		{
			AddElement( pElement->Clone() );
			bChanged = TRUE;
		}
		else if ( pTarget->Merge( pElement, bOverwrite ) )
		{
			bChanged = TRUE;
		}
	}

	for ( POSITION pos = pInput->GetAttributeIterator(); pos; )
	{
		CXMLAttribute* pAttribute = pInput->GetNextAttribute( pos );
		CXMLAttribute* pTarget = GetAttribute( pAttribute->m_sName );

		if ( pTarget == NULL )
		{
			AddAttribute( pAttribute->Clone() );
			bChanged = TRUE;
		}
		else if ( bOverwrite && ! pTarget->Equals( pAttribute ) )
		{
			pTarget->SetValue( pAttribute->GetValue() );
			bChanged = TRUE;
		}
	}

	if ( bChanged )
		TRACE( "resulting XML: %s\n", (LPCSTR)CT2A( ToString( FALSE, FALSE ) ) );
	else
		TRACE( "resulting XML unchanged.\n" );

	return bChanged;
}

void Rectan::Save(ofstream& out)
{
	int x = min(m_x1, m_x2);
	int y = min(m_y1, m_y2);
	int width = abs(m_x1 - m_x2);
	int height = abs(m_y1 - m_y2);
	CString temp;
	temp.Format(_T(" fill=\"rgb(%d, %d, %d)\""), m_Background_Color.GetRed(), m_Background_Color.GetGreen(), m_Background_Color.GetBlue());
	out << "<rect x=\"" << x << "\" y=\"" << y << "\" width=\"" << width << "\" height=\"" << height << "\"";
	out << CT2A(temp);
	temp.Format(_T(" stroke=\"rgb(%d, %d, %d)\""), m_Color.GetRed(), m_Color.GetGreen(), m_Color.GetBlue());
	out << CT2A(temp);
	out << " stroke-width=\"" << m_Width << "\" />";
}

/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
bool CWinInetEvents::RegexMatch(CString str, CString regex) {
  bool matched = false;

  if (str.GetLength()) {
    if (!regex.GetLength() || !regex.Compare(_T("*")) || !str.CompareNoCase(regex)) {
      matched = true;
    } else if (regex.GetLength()) {
        std::tr1::regex match_regex(CT2A(regex), std::tr1::regex_constants::icase | std::tr1::regex_constants::ECMAScript);
        matched = std::tr1::regex_match((LPCSTR)CT2A(str), match_regex);
    }
  }

  return matched;
}

int _tmain(int argc, _TCHAR* argv[])
{
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

	IODispatcher ioService(GetFitThreadNum());
	

	try
	{
		std::string ip;
		if( argc > 1 )
			ip = CT2A(argv[1]);
		else
			ip = "127.0.0.1";

		std::vector<Client *> clis;
		size_t cnt = 1;
		if( argc > 2 )
			cnt = _tstoi(argv[2]);

		clis.resize(cnt);
		for(size_t i = 0; i != cnt; ++i)
			clis.push_back(new Client(ioService, ip.c_str(), 5050));


		system("pause");
	}
	catch(std::exception &e)
	{
		std::cout << e.what() << std::endl;
	}
	
	return 0;
}

void CVNOCLoginDlg::OnBnClickedOk()
{
    UpdateData(TRUE);
	Global->Logf(LogFile_Net,_T("登陆操作，用户名:%s 密码:%s\n"), m_strUsername, m_strPassword);
	if (m_strUsername.IsEmpty())
	{
		OnOK();
	}

	SHA1 shaer;
	shaer.Reset();

	CStringA pwdBuffer = CT2A(m_strPassword);
	shaer.Input(pwdBuffer,pwdBuffer.GetLength());
	UINT pResult[5];
	shaer.Result(pResult);
	pwdBuffer.Format("%08x%08x%08x%08x%08x"
		,pResult[0],pResult[1],pResult[2],pResult[3],pResult[4]);
	Global->Logf(LogFile_General,_T("SHA1后的密码为:%s\n"),CA2T(pwdBuffer));

	INetCenter *pInet=NULL;
	Global->GetINetCenter(&pInet);
	ATLASSERT(pInet);
	if (pInet)
	{
		MSG_RLI mRli;
		mRli.SetAccountNumber((byte*)(LPCTSTR)m_strUsername,m_strUsername.GetLength()*sizeof(TCHAR));
		mRli.SetPassword((byte*)(LPCSTR)pwdBuffer,pwdBuffer.GetLength()*sizeof(TCHAR));
		pInet->SendServer(mRli);

		_SetVerifyState(TRUE);
		SetTimer(0,5000,NULL);
	}
}

CTransferFile* CTransferFiles::Open(LPCTSTR pszFile, BOOL bWrite)
{
	CSingleLock pLock( &m_pSection, TRUE );

	CTransferFile* pFile = NULL;
	if ( m_pMap.Lookup( pszFile, pFile ) )
	{
		if ( bWrite && ! pFile->EnsureWrite() )
			return NULL;
	
		pFile->AddRef();
	}
	else
	{
		pFile = new CTransferFile( pszFile );
		if ( ! pFile->Open( bWrite ) )
		{
			DWORD dwError = GetLastError();
			pFile->Release();
			SetLastError( dwError );
			return NULL;
		}

		m_pMap.SetAt( pFile->m_sPath, pFile );

		TRACE( "Transfer Files : Opened \"%s\" [%s]\n", (LPCSTR)CT2A( pszFile ), ( bWrite ? "write" : "read" ) );
	}

	return pFile;
}

 void Restore(IPersistable * window) const
 {
     clib::recursive_mutex::scoped_lock lock(m_mutex);
     WINDOWPLACEMENT placement;
     std::string encodedStr = CT2A(m_props.Get(PERSIST_PLACEMENT));
     int decodedLen = sizeof(WINDOWPLACEMENT);
     BOOL hr = Base64Decode(encodedStr.c_str(), encodedStr.length(), reinterpret_cast<BYTE *>(&placement), &decodedLen);
     if (hr && placement.length == sizeof(WINDOWPLACEMENT))
     {
         if (placement.showCmd == SW_SHOWMINIMIZED)
         {
             //(Prevent Launch To Minimized)
             placement.showCmd = SW_SHOWNORMAL;
         }
         RECT rMaxWA;
         ::SystemParametersInfo(SPI_GETWORKAREA, 0, &rMaxWA, 0);
         if( (placement.rcNormalPosition.left >= rMaxWA.left) &&
             (placement.rcNormalPosition.top >= rMaxWA.top) &&
             (placement.rcNormalPosition.right <= rMaxWA.right) &&
             (placement.rcNormalPosition.bottom <= rMaxWA.bottom) )
         {
             // If All Values Within The Visible Screen (Taking Into Account Only The Primary Monitor...!), Set The Placement
             ::SetWindowPlacement(window->GetHwnd(), &placement);
         }
     }
     window->RestorePersistInfo(m_props);
 }

BOOL CCPPhDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

	// TODO: Add extra initialization here
	
	this->flog.open(_T("cpph.log")); //open log

	SetTimer(1, 1000, 0); //timer to show minutes to close

	//established token
	this->established_token_status = this->token.establish_token();
	TCHAR msg_char[200];
	if (this->established_token_status == 0){
		this->token.list_containers(this->token_containeres);
		if (this->cur_container_name != this->token_containeres[this->cur_container_id]){ //if not displayed, show it
			wsprintf(msg_char, _T("%s \"%S\""), STATIC_TEXT_1, this->token_containeres[this->cur_container_id].c_str());
			mMsg.SetWindowTextW(msg_char);
			this->cur_container_name = this->token_containeres[this->cur_container_id];
			this->flog << this->loctime() << ": Established container: " << this->cur_container_name << endl; //log
		}
	}
	
	TCHAR l[100];
	GetKeyboardLayoutName(l);
	this->flog << this->loctime() << ": Current leyboard layout: " << CT2A(l) << endl;

	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CThumbCache::InitDatabase()
{
	auto_ptr< CDatabase > db( theApp.GetDatabase( DB_THUMBS ) );
	if ( ! *db )
	{
		TRACE( "CThumbCache::InitDatabase : Database error: %s\n", (LPCSTR)CT2A( db->GetLastErrorMessage() ) );
		return;
	}

	// Recreate table
	if ( ! db->Exec( L"CREATE TABLE Files ("
			 L"Filename TEXT UNIQUE NOT NULL PRIMARY KEY, "
			 L"FileSize INTEGER NOT NULL, "
			 L"LastWriteTime INTEGER NOT NULL, "
			 L"Image BLOB NOT NULL, "	// as JPEG
			 L"Flags INTEGER DEFAULT 0 NULL, "
			 L"SHA1 TEXT NULL, TTH TEXT NULL, ED2K TEXT NULL, MD5 TEXT NULL); "
			 L"CREATE INDEX IDX_SHA1 ON Files(SHA1 ASC); "
			 L"CREATE INDEX IDX_TTH ON Files(TTH ASC); "
			 L"CREATE INDEX IDX_ED2K ON Files(ED2K ASC); "
			 L"CREATE INDEX IDX_MD5 ON Files(MD5 ASC);" ) )
	{
		// Cleanup existing
		//TIMER_START
		theApp.KeepAlive();
		db->Exec( L"PRAGMA synchronous=OFF" );		// Async return (15% faster, ~1sec)
		db->Exec( L"PRAGMA journal_mode=OFF" );		// No temp "-journal" rollback file created (2X time)
		db->Exec( L"VACUUM;" );						// Several seconds if large
		theApp.KeepAlive();
		//TIMER_STOP
	}
}

BOOL IsIPAddress(LPCTSTR lpszAddress)
{
	if(!lpszAddress || lpszAddress[0] == '\0')
		return FALSE;

	return ::inet_addr(CT2A(lpszAddress)) != INADDR_NONE;
}

CString CodePassword(LPCTSTR decrypted)
{
	CString crypted;
	char cDecrypted[256] = { 0 };
	strcpy(cDecrypted, CT2A(decrypted));
	char *p = cDecrypted;
	while (*p != '\0')
	{
		for (int i = 0; i < 256; i++)
		{
			if (*p == CodeBook[i])
			{
				TCHAR code[3] = {0};
				wsprintf((LPWSTR)code, _T("%02x"), i);
				crypted.AppendChar(code[0]);
				crypted.AppendChar(code[1]);
				break;
			}
		}

		p++;
	}

	return crypted;
}

BOOL CYYApiMgr::Rename(CString nick)
{
	if (g_pYYExApi == NULL)
	{
		return FALSE;
	}

	yy::IUserEx* pUser = g_pYYExApi->GetUser();
	if (pUser == NULL)
	{
		return FALSE;
	}

	if (nick.GetLength() > max_nick_length)
	{
		nick.Delete(max_nick_length, nick.GetLength()-max_nick_length);
	}

	char name[256] = {0};
	strcpy(name, CT2A(nick, CP_UTF8));
	unsigned int nError = pUser->Rename(name);
	if (nError != yy_success)
	{
		return FALSE;
	}

	return TRUE;
}

/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
int	CWsHook::getaddrinfo(PCSTR pNodeName, PCSTR pServiceName, const ADDRINFOA * pHints, PADDRINFOA * ppResult)
{
	int ret = WSAEINVAL;
	bool overrideDNS = false;

	void * context = NULL;
	CString name = CA2T(pNodeName);
	CAtlArray<DWORD> addresses;
	if( dlg )
		overrideDNS = dlg->DnsLookupStart( name, context, addresses );

	if( _getaddrinfo && !overrideDNS )
		ret = _getaddrinfo(CT2A((LPCTSTR)name), pServiceName, pHints, ppResult);
	else if( overrideDNS ) {
		if( addresses.IsEmpty() )
			ret = EAI_NONAME;
		else {
			// build the response structure with the addresses we looked up
			ret = 0;
			DWORD count = addresses.GetCount();

			ADDRINFOA_ADDR * result = (ADDRINFOA_ADDR *)malloc(sizeof(ADDRINFOA_ADDR) * count);
			for (DWORD i = 0; i < count; i++) {
				memset( &result[i], 0, sizeof(ADDRINFOA_ADDR) );
				result->info.ai_family = AF_INET;
				result->info.ai_addrlen = sizeof(struct sockaddr_in);
				result->info.ai_addr = (struct sockaddr *)&(result->addr);
				result->addr.sin_family = AF_INET;
				result->addr.sin_addr.S_un.S_addr = addresses[i];
				if( i < count - 1 )
					result->info.ai_next = (PADDRINFOA)&result[i+1];
			}
			addrInfo.AddTail(result);

			*ppResult = (PADDRINFOA)result;
		}
	}

	if (!ret && dlg) {
		PADDRINFOA addr = *ppResult;
		while (addr) {
      if (addr->ai_canonname)
        dlg->DnsLookupAlias(name, (LPCTSTR)CA2T(addr->ai_canonname));

			if (context &&
          addr->ai_addrlen >= sizeof(struct sockaddr_in) && 
          addr->ai_family == AF_INET) {
				struct sockaddr_in * ipName = (struct sockaddr_in *)addr->ai_addr;
				dlg->DnsLookupAddress(context, ipName->sin_addr);
			}

			addr = addr->ai_next;
		}

    if (context)
		  dlg->DnsLookupDone(context);
	}

	return ret;
}

BOOL CIocpServer::CreateListenSocket(LPCTSTR pszBindAddress, USHORT usPort)
{
	BOOL isOK = FALSE;

	m_soListen	= socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if(m_soListen != INVALID_SOCKET)
	{
		SOCKADDR_IN addr;
		addr.sin_family			= AF_INET;
		addr.sin_addr.s_addr	= inet_addr(CT2A(pszBindAddress));
		addr.sin_port			= ::htons(usPort);

		if(::bind(m_soListen, (SOCKADDR*)&addr, sizeof(SOCKADDR_IN)) != SOCKET_ERROR)
		{
			if(::listen(m_soListen, m_dwSocketListenQueue) != SOCKET_ERROR)
			{
				m_pfnAcceptEx				= ::Get_AcceptEx_FuncPtr(m_soListen);  //取得接收扩展函数AcceptEx指针
				m_pfnGetAcceptExSockaddrs	= ::Get_GetAcceptExSockaddrs_FuncPtr(m_soListen);//最得GetAcceptExSockaddrs扩展函数指针

				ASSERT(m_pfnAcceptEx);
				ASSERT(m_pfnGetAcceptExSockaddrs);

				isOK = TRUE;
			}
			else
				SetLastError(ISS_SOCKET_LISTEN, _T(__FUNCTION__), ::WSAGetLastError());
		}
		else
			SetLastError(ISS_SOCKET_BIND, _T(__FUNCTION__), ::WSAGetLastError());
	}
	else
		SetLastError(ISS_SOCKET_CREATE, _T(__FUNCTION__), ::WSAGetLastError());

	return isOK;
}

void versionManager::getMainModuleVersion(VMMAPDEF& mapVersion)
{
	std::string   strVersion = "";
	TCHAR szBankPath[1000];

	_tcscpy_s(szBankPath, getModulePath().c_str());
	_tcscat_s(szBankPath, _T("\\MoneyHub.exe"));

	CFileVersionInfo vinfo;
	if (vinfo.Create(szBankPath))
	{
		tstring strFileVersion = vinfo.GetFileVersion();
		replace(strFileVersion.begin(), strFileVersion.end(), ',', '.');
		strFileVersion.erase(remove(strFileVersion.begin(), strFileVersion.end(), ' '), strFileVersion.end());
		strVersion = std::string(CT2A(strFileVersion.c_str(), 936));
	}
	else 
		return ;

	USES_CONVERSION;
	if(m_bEnName)
		mapVersion.insert(std::make_pair(L"Main",A2W(strVersion.c_str()) ) );
	else
	{
	    VMMAPDEF::iterator it = m_mapEnChName.find(L"Main");
		if( it != m_mapEnChName.end() )
			mapVersion.insert(std::make_pair(it->second.c_str(), A2W(strVersion.c_str()) ) );
	}
}

CClientDlg::CClientDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CClientDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

	VERIFY(g_CookieMgr.LoadFromFile(CT2A(g_lpszDefaultCookieFile), FALSE) || ::GetLastError() == ERROR_FILE_NOT_FOUND);
}