cppstring GTextUtils::ConvertNarrowStringToWide(const narrowstring sNarrow)
{
// input a narrow (ASCII )string ... it will not be multibyte 
// convert to wide if USE_WIDE_CHARS

#ifdef USE_WIDE_CHARS
	cppstring sResult(sNarrow.c_str());

#else
	cppstring sResult(sNarrow); // the types are the same... does nothing
#endif
	return sResult;
}
void GPageLoadRequestManager::ProcessRequest(GUpdateCurrentPageRequest* pRequest)
{
	LOG_LEVEL4("ProcessRequest(GUpdateCurrentPageRequest)");

	QString sResult("discarded");

	if( m_oPreSetManager.IsActive() && m_oPreSetManager.CanProcessRequest(pRequest) )
	{
		m_oPreSetManager.ProcessRequest(pRequest);
		sResult = "completed";
	}

	if( m_oNonPreSetManager.IsActive() && m_oNonPreSetManager.CanProcessRequest(pRequest) )
	{
		m_oNonPreSetManager.ProcessRequest(pRequest);
		sResult = "completed";
	}

	static QString const strTemp("(GUpdateCurrentPageRequest): RequestId(%1), has been completed with result (%2) for (%3).");
	LOG_LEVEL4(QString(strTemp) . arg(pRequest->GetRequestId()) . arg(sResult) . arg(GetSessionName(pRequest->GetSessionId())));

	if( pRequest->IsSynchronize() )
	{
		GAbsView::SignalSynchronize( (sResult=="completed")?(true):(false) );
	}
	delete pRequest;
}
std::string UriDecode(const std::string& sSrc) {
    // Note from RFC1630:  "Sequences which start with a percent sign
    // but are not followed by two hexadecimal characters (0-9, A-F) are reserved
    // for future extension"

    const unsigned char        *pSrc        = (const unsigned char *)sSrc.c_str();
    const int                  SRC_LEN      = sSrc.length();
    const unsigned char *const SRC_END      = pSrc + SRC_LEN;
    const unsigned char *const SRC_LAST_DEC = SRC_END - 2;    // last decodable '%'

    char *const pStart = new char[SRC_LEN];
    char        *pEnd  = pStart;

    while (pSrc < SRC_LAST_DEC) {
        if (*pSrc == '%') {
            char dec1, dec2;
            if ((-1 != (dec1 = HEX2DEC[*(pSrc + 1)])) &&
                (-1 != (dec2 = HEX2DEC[*(pSrc + 2)]))) {
                *pEnd++ = (dec1 << 4) + dec2;
                pSrc   += 3;
                continue;
            }
        }

        *pEnd++ = *pSrc++;
    }

    // the last 2- chars
    while (pSrc < SRC_END)
        *pEnd++ = *pSrc++;

    std::string sResult(pStart, pEnd);
    delete [] pStart;
    return sResult;
}
Beispiel #4
0
std::string GetAppPath()
{
	ERROR_OUTPUT(__func__);
	char result[PATH_MAX] = {0};
	ssize_t count = readlink("/proc/self/exe", result, PATH_MAX);

	if (count <= 0)
	{
		ERROR_OUTPUT("Could not get program directory!");
		return "";
	}

	for(size_t i = count - 1; i > 0; i--)
	{
		if(result[i] == '/')
		{
			result[i] = '\0';
			break;
		}
	}

	std::string sResult(result);
	size_t pos = sResult.find_last_of('/');

	// we actually want one folder above where we are due to executable being in desura/bin/
	sResult = sResult.substr(0, pos);

	ERROR_OUTPUT(sResult.c_str());
	return sResult;
}
Beispiel #5
0
void C4GameOverDlg::SetNetResult(const char *szResultString, C4RoundResults::NetResult eResultType, size_t iPendingStreamingData, bool fIsStreaming)
	{
	// add info about pending streaming data
	StdStrBuf sResult(szResultString);
	if (fIsStreaming)
		{
		sResult.AppendChar('|');
		sResult.AppendFormat("[!]Transmitting record to league server... (%d kb remaining)", int(iPendingStreamingData/1024));
		}
	// message linebreak into box
	StdStrBuf sBrokenResult;
	C4GUI::GetRes()->TextFont.BreakMessage(sResult.getData(), pNetResultLabel->GetBounds().Wdt, &sBrokenResult, true);
	pNetResultLabel->SetText(sBrokenResult.getData(), false);
	// all done?
	if (eResultType != C4RoundResults::NR_None && !fIsStreaming)
		{
		// a final result is determined and all streaming data has been transmitted
		fIsNetDone = true;
		}
	// network error?
	if (eResultType == C4RoundResults::NR_NetError)
		{
		// disconnected. Do not show winners/losers
		for (int32_t i=0; i<iPlrListCount; ++i) ppPlayerLists[i]->SetMode(C4PlayerInfoListBox::PILBM_EvaluationNoWinners);
		}
	}
Beispiel #6
0
		std::string Utf16ToUtf8( const wchar_t* const szSource, const _U32 uiSize )
		{
			static std::string sWrongString = "\"String::Utf16ToUtf8 Conversion Failed\"";
			if ( uiSize == 0 )
			{
				return std::string();
			}

			const int iRequiredLength = WideCharToMultiByte( CP_UTF8, 0, szSource, uiSize, NULL, 0, NULL, NULL );
			if ( iRequiredLength == 0 )
			{
				//ALOGE( gLogRoot, "Failed to determine length of the converted UTF-8 string: %d", GetLastError() );
				return sWrongString;
			}

			std::string sResult( iRequiredLength, '\0' );
			const int iConvertResult = WideCharToMultiByte( CP_UTF8, 0, szSource, uiSize, const_cast<char*>( sResult.data() ), iRequiredLength, NULL, NULL );
			if ( iConvertResult != iRequiredLength )
			{
				//ALOGE( gLogRoot, "Failed to convert UTF-16 string to UTF-8 string: %d", GetLastError() );
				return sWrongString;
			}

			return sResult;
		}
Beispiel #7
0
std::string UriEncode(const std::string & sSrc)
{
	const char DEC2HEX[16 + 1] = "0123456789ABCDEF";
	const unsigned char * pSrc = (const unsigned char *)sSrc.c_str();
	const int SRC_LEN = sSrc.length();
	unsigned char * const pStart = new unsigned char[SRC_LEN * 3];
	unsigned char * pEnd = pStart;
	const unsigned char * const SRC_END = pSrc + SRC_LEN;

	for (; pSrc < SRC_END; ++pSrc)
	{
		if (SAFE[*pSrc]) 
			*pEnd++ = *pSrc;
		else
		{
			// escape this char
			*pEnd++ = '%';
			*pEnd++ = DEC2HEX[*pSrc >> 4];
			*pEnd++ = DEC2HEX[*pSrc & 0x0F];
		}
	}

	std::string sResult((char *)pStart, (char *)pEnd);
	delete [] pStart;
	return sResult;
}
Beispiel #8
0
std::string UriDecode(const std::string & sSrc) {
    const unsigned char * pSrc = (const unsigned char *)sSrc.c_str();
    const long SRC_LEN = sSrc.length();
    const unsigned char * const SRC_END = pSrc + SRC_LEN;
    const unsigned char * const SRC_LAST_DEC = SRC_END - 2;

    char * const pStart = new char[SRC_LEN];
    char * pEnd = pStart;

    while (pSrc < SRC_LAST_DEC) {
        if (*pSrc == '%') {
            char dec1, dec2;
            if (-1 != (dec1 = HEX2DEC[*(pSrc + 1)])
                && -1 != (dec2 = HEX2DEC[*(pSrc + 2)])) {
                *pEnd++ = (dec1 << 4) + dec2;
                pSrc += 3;
                continue;
            }
        }

        *pEnd++ = *pSrc++;
    }

    while (pSrc < SRC_END)
        *pEnd++ = *pSrc++;

    std::string sResult(pStart, pEnd);
    delete [] pStart;
    return sResult;
}
Beispiel #9
0
		std::string MultiByteToUtf8( const char* const szSource, const _U32 uiSize )
		{
			static std::string sWrongString = "\"String::MultiByteToUtf8 Conversion Failed\"";
			if ( uiSize == 0 )
			{
				return std::string();
			}

			const int iRequiredLength = MultiByteToWideChar( CP_ACP, MB_ERR_INVALID_CHARS, szSource, uiSize, NULL, 0 );
			if ( iRequiredLength == 0 )
			{
				//ALOGE( gLogRoot, "Failed to determine length of converted UTF-8 string: %d", GetLastError() );
				return sWrongString;
			}

			std::wstring sResult( iRequiredLength, L'\0' );
			const int iConvertResult = MultiByteToWideChar( CP_ACP, MB_ERR_INVALID_CHARS, szSource, uiSize, const_cast<wchar_t*>( sResult.data() ), iRequiredLength );
			if ( iConvertResult != iRequiredLength )
			{
				//ALOGE( gLogRoot, "Failed to convert MultiByte string to UTF-8 string: %d", GetLastError() );
				return sWrongString;
			}

			return Utf16ToUtf8( sResult );
		}
Beispiel #10
0
eString Mid(const eString &str, const unsigned int start, const unsigned int length)
{
	unsigned int len = length;
	unsigned int sPos = start;
	
	char *lpszResult;

	// Error Checking
	if (sPos > 0) sPos--;
	if (sPos < 0) return "";
	if (sPos >= str.eStr_Len) return "";
	if (len == 0) len = str.eStr_Len;
	if (len > str.eStr_Len) len = str.eStr_Len;
	
	if ((sPos + len) > str.eStr_Len)
		len = (str.eStr_Len - sPos);

	lpszResult = new char [(len + 1)];
	strncpy(lpszResult, (&(str.eStr_Str[sPos])), len);
	lpszResult[len] = 0;

	eString sResult(lpszResult);
	delete [] lpszResult;

	return sResult;
}
Beispiel #11
0
		std::string Utf8ToMultiByte( const char* const szSource, const _U32 uiSize )
		{
			static std::string sWrongString = "\"String::MultiByteToUtf8 Conversion Failed\"";
			if ( uiSize == 0 )
			{
				return std::string();
			}

			std::wstring wsTemp = String::Utf8ToUtf16( szSource, uiSize );

			const int iRequiredLength = WideCharToMultiByte( CP_ACP, 0, wsTemp.c_str(), (_U32)( wsTemp.length() ), NULL, 0, NULL, NULL );
			if ( iRequiredLength == 0 )
			{
				//ALOGE( gLogRoot, "Failed to determine length of the converted MultiByte string: %d", GetLastError() );
				return sWrongString;
			}

			std::string sResult( iRequiredLength, '\0' );
			const int iConvertResult = WideCharToMultiByte( CP_ACP, 0, wsTemp.c_str(), (_U32)( wsTemp.length() ), const_cast<char*>( sResult.data() ), iRequiredLength, NULL, NULL );
			if ( iConvertResult != iRequiredLength )
			{
				//ALOGE( gLogRoot, "Failed to convert UTF-8 string to MultiByte string: %d", GetLastError() );
				return sWrongString;
			}

			return sResult;
		}
//        /// <summary>
//        /// Get string array from ptr
//        /// </summary>
//        internal static string[] GetStringArrayFromPtrLA(IntPtr pointer, int nLength)
//        {
//            IntPtr[] rawRows = new IntPtr[nLength];
//            string[] oResult = new string[nLength];
//            Marshal.Copy(pointer, rawRows, 0, nLength);
//
//            for (int i = 0; i < nLength; i++)
//            {
//                oResult[i] = Marshal.PtrToStringAnsi(rawRows[i]);
//            } // for (int)
//
//            LA.FreeMatrix(pointer, nLength);
//            return oResult;
//        } // GetStringArrayFromPtrLA(pointer, nLength)
//
/// <summary>
/// Get string from ptr
/// </summary>
string GetStringFromPtr(IntPtr &pointer, int nLength)
{
    char* oneString = (char*) pointer;
//    string sResult = Marshal.PtrToStringAnsi(pointer, nLength);
//    StructAnalysis.FreeVector(pointer);
    string sResult(oneString);
    return sResult;
}
Beispiel #13
0
CString CString::ToLower() const {
  CString sResult(* this);

  for (T_ULONG i = 0; i < sResult.m_Length; i++) {
    if ((sResult.m_String[i] >= 65) && (sResult.m_String[i] <= 90)) {
      sResult.m_String[i] = sResult.m_String[i] + 32;
    }
  }

  return (sResult);
} // ToLower
Beispiel #14
0
CString CString::ToUpper() const {
  CString sResult(* this);

  for (T_ULONG i = 0; i < sResult.m_Length; i++) {
    if ((sResult.m_pString[i] >= 97) && (sResult.m_pString[i] <= 122)) {
      sResult.m_pString[i] = sResult.m_pString[i] - 32;
    }
  }

  return (sResult);
} // ToLower
/** Format a string by performing substitution
  * It is mainly intended for formatting Configuration names such as "'$(Configuration)|$(Platform)'=='Debug|Win32'"
  * \param sString : the string to format
  * \return the formatted string
  */
wxString MSVC10Loader::SubstituteConfigMacros(const wxString& sString)
{
    wxString sResult(sString);

    sResult.Replace(_T("$(Configuration)"), _T(""));
    sResult.Replace(_T("$(Platform)"),      _T(""));
    sResult.Replace(_T("=="),               _T(""));
    sResult.Replace(_T("\'"),               _T(""));
    sResult.Replace(_T("|"),                _T(" "));
    sResult.Trim(false);

    return sResult;
}
Beispiel #16
0
CString CString::operator+(const CString & tString) const {
  CString sResult((T_CHAR *)NULL);

  sResult.m_Length = m_Length + tString.m_Length;
  if (sResult.m_Length != 0) {
    sResult.m_pString = (T_CHAR *)malloc((sResult.m_Length + 1) * sizeof(T_CHAR));
    STATIC_strcpy(sResult.m_pString, m_pString, m_Length);
    STATIC_strcpy(sResult.m_pString + m_Length, tString.m_pString, tString.m_Length);
    sResult.m_pString[sResult.m_Length] = '\0';
  }

  return (sResult);
} // operator+
Beispiel #17
0
/********************************************//**
 * Safe encode URL
 ***********************************************/
std::string CE2STBUtils::URLEncodeInline(const std::string& strURL)
{
  const char SAFE[256] =
  {
  /*     0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F */
  /* 0 */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* 1 */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* 2 */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* 3 */1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,

  /* 4 */0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  /* 5 */1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
  /* 6 */0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  /* 7 */1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,

  /* 8 */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* 9 */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* A */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* B */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  /* C */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* D */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* E */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* F */0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

  const char DEC2HEX[16 + 1] = "0123456789ABCDEF";
  const unsigned char * pSrc = (const unsigned char *) strURL.c_str();
  const int SRC_LEN = strURL.length();
  unsigned char * const pStart = new unsigned char[SRC_LEN * 3];
  unsigned char * pEnd = pStart;
  const unsigned char * const SRC_END = pSrc + SRC_LEN;

  for (; pSrc < SRC_END; ++pSrc)
  {
    if (SAFE[*pSrc])
    {
      *pEnd++ = *pSrc;
    }
    else
    {
      // escape this char
      *pEnd++ = '%';
      *pEnd++ = DEC2HEX[*pSrc >> 4];
      *pEnd++ = DEC2HEX[*pSrc & 0x0F];
    }
  }

  std::string sResult((char *) pStart, (char *) pEnd);
  delete[] pStart;
  return sResult;
}
Beispiel #18
0
AVSINLINE const CStringA Encoding::wstring2string(const CStringW &sLine, const unsigned int unCodePage)
{
	const int nSize = WideCharToMultiByte( unCodePage, 0, sLine.GetString(), sLine.GetLength(), NULL, 0, NULL, NULL );
	char *sTemp = new char[nSize];
	if ( !sTemp )
		return "";
	
	WideCharToMultiByte( unCodePage, 0, sLine.GetString(), sLine.GetLength(), sTemp, nSize, NULL, NULL );

	CStringA sResult( sTemp );
	delete []sTemp;

	return sResult;
}
Beispiel #19
0
CString CPath::AddBackSlash(LPCTSTR szFolderPath, BOOL bInverted)
{
	CString sResult(szFolderPath);
	int		nLastChar = sResult.GetLength() - 1;

	if(nLastChar >= 0)
	{
		if((sResult[nLastChar] != _T('\\')) && (sResult[nLastChar] != _T('/')))
		{
			sResult += bInverted ? _T('/') : _T('\\');
		}
	}
	return(sResult);
}
Beispiel #20
0
/*---------------------------------------------------------------------------------------------
Name				:	RemoveBackSlash(LPCTSTR szFolderPath)
Purpose				:	Removes a trailing back slash (or normal slash) if found at the end of szFolderPath

Parameters			:
LPCTSTR  szFolderPath - Source path
Return				:	CString - new path
Globals Modified	:	None.
--------------------------------------------------------------------------------------------*/
CString CPath::RemoveBackSlash(LPCTSTR szFolderPath)
{
	CString sResult(szFolderPath);
	int		nLastChar = sResult.GetLength() - 1;

	if(nLastChar >= 0)
	{
		if((sResult[nLastChar] == _T('\\')) || (sResult[nLastChar] == _T('/')))
		{
			sResult = sResult.Left(nLastChar);
		}
	}

	return(sResult);
}
Beispiel #21
0
AVSINLINE const CStringW Encoding::string2wstring(const CStringA &sLine, const unsigned int unCodePage)
{
	const int nSize = MultiByteToWideChar( unCodePage, 0, sLine.GetString(), sLine.GetLength(), NULL, 0 );

	wchar_t *sTemp = new wchar_t[nSize];
	if ( !sTemp )
		return _T("");

	MultiByteToWideChar( unCodePage, 0, sLine.GetString(), sLine.GetLength(), sTemp, nSize );

	CStringW sResult( sTemp );
	delete []sTemp;

	return sResult;
}
Beispiel #22
0
QString UPnpCDSExtension::RemoveToken( const QString &sToken, const QString &sStr, int num )
{
    QString sResult( "" );
    int     nPos = -1;

    for (int nIdx=0; nIdx < num; nIdx++)
    {
        if ((nPos = sStr.findRev( sToken, nPos )) == -1)
            break;
    }

    if (nPos > 0)
        sResult = sStr.left( nPos );

    return sResult;
}
void GPageLoadRequestManager::Notify(GLoadersManagerRequestNotify &oNotify) throw(GException)
{
	LOG_LEVEL4("Notify()");

	QMutexLocker oLocker(&m_qmInternalMutex);

	GAbsPageLoadRequest* pRequest(0);

	for( int i = 0; i < m_qlsReqs.size(); ++i )
	{
		if( m_qlsReqs.at(i)->GetRequestId() == oNotify.GetRequest()->GetRequestId() )
		{
			pRequest = oNotify.GetRequest();
			m_qlsReqs.removeAt(i);
			break;
		}
	}

	if( pRequest != 0 )
	{
		QString sResult("Timeout");
		if( oNotify.GetNofifyType() == GLoadersManagerRequestNotify::eContentLoadComplete )
		{
			m_pMainView->setPage(oNotify.GetWebPage());
			sResult = "Completed";

			SetAsActive(oNotify.GetLoadersManagerId());
		}

		static QString const strTemp("RequestId(%1), has been completed with result (%2) for (%3).");
		LOG_LEVEL4(QString(strTemp) . arg(pRequest->GetRequestId()) . arg(sResult) . arg(GetSessionName(pRequest->GetSessionId())));

		if( pRequest->IsSynchronize() )
		{
			GAbsView::SignalSynchronize( (sResult=="Completed")?(true):(false) );
		}

		delete pRequest;

		ProcessNewRequest();

		return;
	}

	throw(GException("Cannot found the request in the internal queue."));
}
Beispiel #24
0
/** decodes a URI encoded string into a normal string. */
static std::string uriDecode(const std::string & sSrc)
{
  // Note from RFC1630: "Sequences which start with a percent
  // sign but are not followed by two hexadecimal characters
  // (0-9, A-F) are reserved for future extension"

  const unsigned char * pSrc = (const unsigned char *)sSrc.c_str();
  const int SRC_LEN = sSrc.length();
  const unsigned char * const SRC_END = pSrc + SRC_LEN;
  // last decodable '%'
  const unsigned char * const SRC_LAST_DEC = SRC_END - 2;

  char * const pStart = new char[SRC_LEN];
  char * pEnd = pStart;

  while (pSrc < SRC_LAST_DEC)
  {
    if (*pSrc == '%') // replace %2A with corresponding ASCII character
    {
      char dec1, dec2;
      unsigned char c1=*(pSrc+1);
      unsigned char c2=*(pSrc+2);
      if (-1 != (dec1 = HEX2DEC(c1))
       && -1 != (dec2 = HEX2DEC(c2)))
      {
        *pEnd++ = (dec1 << 4) + dec2;
        pSrc += 3;
        continue;
      }
    }
    else if (*pSrc == '+') // replace '+' with space
    {
      *pEnd++ = ' '; pSrc++;
      continue;
    }
    *pEnd++ = *pSrc++;
  }

  // the last 2- chars
  while (pSrc < SRC_END) *pEnd++ = *pSrc++;

  std::string sResult(pStart, pEnd);
  delete [] pStart;
  return sResult;
}
Beispiel #25
0
	//把宽字符串转换成字符串,输出使用  
	AINIKU_API string wstring2string(wstring sToMatch)
	{
#ifdef _A_LINUX   
		int iLen = wcstombs(NULL, sToMatch.c_str(), 0); // 计算转换后字符串的长度。(不包含字符串结束符)  
		char *lpsz = new char[iLen + 1];
		int i = wcstombs(lpsz, sToMatch.c_str(), iLen); // 转换。(没有结束符)  
		lpsz[iLen] = '/0';
		string sResult(lpsz);
		delete[]lpsz;
#else 
		string sResult;
		int iLen = WideCharToMultiByte(CP_ACP, NULL, sToMatch.c_str(), -1, NULL, 0, NULL, FALSE); // 计算转换后字符串的长度。(包含字符串结束符)  
		char *lpsz = new char[iLen];
		WideCharToMultiByte(CP_OEMCP, NULL, sToMatch.c_str(), -1, lpsz, iLen, NULL, FALSE); // 正式转换。  
		sResult.assign(lpsz, iLen - 1); // 对string对象进行赋值。  
		delete[]lpsz;
#endif  
		return sResult;
	}
Beispiel #26
0
 //---------------------------------------------------------
 //---------------------------------------------------------
 std::string URLDecode(const std::string& instrSrc)
 {
     // Note from RFC1630: "Sequences which start with a percent
     // sign but are not followed by two hexadecimal characters
     // (0-9, A-F) are reserved for future extension"
     
     const unsigned char* pSrc = (const unsigned char*)instrSrc.c_str();
     const u32 udwSourceLength = static_cast<u32>(instrSrc.length());
     const unsigned char* const pSourceEnd = pSrc + udwSourceLength;
     // last decodable '%'
     const unsigned char* const pSourceLastDecode = pSourceEnd - 2;
     
     char* const pStart = new char[udwSourceLength];
     char* pEnd = pStart;
     
     while(pSrc < pSourceLastDecode)
     {
         if(*pSrc == '%')
         {
             char dec1 = static_cast<char>(Utils::HexToDec((pSrc + 1)));
             char dec2 = static_cast<char>(Utils::HexToDec((pSrc + 2)));
             if(-1 != dec1 && -1 != dec2)
             {
                 *pEnd++ = (dec1 << 4) + dec2;
                 pSrc += 3;
                 continue;
             }
         }
         *pEnd++ = *pSrc++;
     }
     
     // the last 2- chars
     while(pSrc < pSourceEnd)
     {
         *pEnd++ = *pSrc++;
     }
     
     std::string sResult(pStart, pEnd);
     delete [] pStart;
     return sResult;
 }
Beispiel #27
0
CString CPathFinder::RemoveBackSlash(LPCTSTR szFolderPath)
{
	/*
	CString	sResult(szFolderPath);
	int		nLastChar = sResult.GetLength() - 1;

	if (nLastChar >= 0)
	{
		if ((sResult[nLastChar] == '\\') || (sResult[nLastChar] == '/'))
			sResult = sResult.Left(nLastChar);

	}

	return sResult;

	*/

	CString sResult(szFolderPath);
	sResult.TrimRight('\\');
	
	return sResult;
}
Beispiel #28
0
CString CPathFinder::AddBackSlash(LPCTSTR szFolderPath, BOOL bInverted)
{
	/*
	CString	sResult(szFolderPath);
	int		nLastChar = sResult.GetLength() - 1;

	if (nLastChar >= 0)
	{
		if ((sResult[nLastChar] != '\\') && (sResult[nLastChar] != '/'))
			sResult += bInverted ? '/' : '\\';
	}

	return sResult;
*/

	CString sResult(szFolderPath);
	sResult.TrimRight('\\');
	sResult += '\\'; 
	
	return sResult;


	
}
Beispiel #29
0
//
// Handler
//
INT_32 FnMBSubstring::Handler(CDT            * aArguments,
                              const UINT_32    iArgNum,
                              CDT            & oCDTRetVal,
                              Logger         & oLogger)
{
	// Check number of parameters
	if (iArgNum == 0) { oCDTRetVal = ""; return 0; }

	// substr('foobar', 2) -> 'obar'
	if (iArgNum == 2)
	{
		const UINT_32       iOffset = UINT_32(aArguments[0].GetInt());
		const STLW::string  sResult = aArguments[1].GetString();

		CCHAR_P  szStart  = sResult.data();
		CCHAR_P  szEnd    = sResult.data() + sResult.size();
		INT_32   iPos     = 0;
		UINT_32  iCharPos = 0;
		for(;;)
		{
			INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);

			if (iCharLen == -3) { break; }

			// Check character length
			if (iCharLen < 0) { iCharLen = 1; }
			// Skip errors
			else              { ++iCharPos;   }
			iPos += iCharLen;

			if (iCharPos >= iOffset) { break; }
		}

		if (iCharPos < iOffset) { oCDTRetVal = ""; }
		else                    { oCDTRetVal = sResult.substr(iPos); }

		return 0;
	}
	// substr('foobar', 2, 3) -> 'oba'
	if (iArgNum == 3)
	{
		const UINT_32       iBytes  = UINT_32(aArguments[0].GetInt());
		const UINT_32       iOffset = UINT_32(aArguments[1].GetInt());
		const STLW::string  sResult = aArguments[2].GetString();

		CCHAR_P  szStart  = sResult.data();
		CCHAR_P  szEnd    = sResult.data() + sResult.size();
		INT_32   iPos     = 0;
		UINT_32  iCharOffset = 0;
		UINT_32  iCharPos = 0;
		for(;;)
		{
			INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);

			if (iCharLen == -3) { break; }

			// Check character length
			if (iCharLen < 0) { iCharLen = 1; }
			// Skip errors
			else              { ++iCharPos;   }
			iPos += iCharLen;

			if (iCharPos == iOffset)          { iCharOffset = iPos; }

			if (iCharPos == iOffset + iBytes) { break; }
		}

		if (sResult.size() < iCharOffset) { oCDTRetVal = ""; }
		else                              { oCDTRetVal = sResult.substr(iCharOffset, iPos - iCharOffset); }

		return 0;
	}
	// substr('foobar', 2, 3, '1234567') -> 'fo1234567r'
	if (iArgNum == 4)
	{
		STLW::string        sReplacement = aArguments[0].GetString();
		const UINT_32       iBytes       = UINT_32(aArguments[1].GetInt());
		const UINT_32       iOffset      = UINT_32(aArguments[2].GetInt());
		const STLW::string  sTMP         = aArguments[3].GetString();

		CCHAR_P  szStart  = sTMP.data();
		CCHAR_P  szEnd    = sTMP.data() + sTMP.size();
		UINT_32  iPos     = 0;
		UINT_32  iCharOffset = 0;
		UINT_32  iCharPos = 0;
		for(;;)
		{
			INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);

			if (iCharLen == -3) { break; }

			// Check character length
			if (iCharLen < 0) { iCharLen = 1; }
			// Skip errors
			else              { ++iCharPos;   }
			iPos += iCharLen;

			if (iCharPos == iOffset)          { iCharOffset = iPos; }

			if (iCharPos == iOffset + iBytes) { break; }
		}
		if (sTMP.size() < iCharOffset) { oCDTRetVal = ""; return 0; }

		STLW::string  sResult(sTMP, 0, iCharOffset);
		sResult.append(sReplacement);

		if (iPos == sTMP.size()) { oCDTRetVal = sResult; return 0; }

		sResult.append(sTMP, iPos, STLW::string::npos);
		oCDTRetVal = sResult;
		return 0;
	}

	oLogger.Emerg("Usage: MB_SUBSTR(x, offset[, bytes[, y]]])");
return -1;
}
CString Login(CString strUser,CString strPswod,CString strIp,CString strbForce)
{
	HRESULT hr = ::CoInitialize(NULL);
	CString sResult(""); 
	try
	{
		ProcessClientServicesLib::IRpcCallHelperPtr piClientHelper(__uuidof(ProcessClientServicesLib::RpcCallHelper));
		_bstr_t bstrUser(strUser);
		_bstr_t bstrPassword(strPswod);
		_bstr_t bstrIp(strIp);
		_bstr_t bstrForce(strbForce);

		 sResult = (LPCTSTR)_bstr_t(piClientHelper->ERMDoLogin(bstrUser, bstrPassword,bstrIp,bstrForce));
		 if (sResult.Find("ticket-proxy=") == -1)
		 {
			 if (sResult.Compare("-2") == 0)
			 {
				 printf("系统错误,请确认服务器工作正常\n");
			 }
			 else if (sResult.Compare("-6") == 0)
			 {
				 printf("用户不存在\n");
			 }
			 else if (sResult.Compare("-7") == 0)
			 {
				 printf("密码错误\n");
			 }
			 else if (sResult.Compare("-8") == 0)
			 {
				 printf( "用户被锁定\n");
			 }
			 else if (sResult.Compare("-9") == 0)
			 {
				 printf("用户被删除\n");
			 }
			 else if (sResult.Compare("-10") == 0)
			 {
				 printf("用户被禁用\n");
			 }
			 else
			 {
				 printf("登录失败,请确认服务器工作正常\n");
			 }
		 }
		

	}
	catch (_com_error e)
	{
		CString strErrorMsg = e.ErrorMessage();
		ZTools::WriteZToolsFormatLog("RPC组件调用异常,%s", strErrorMsg);
		return "";
	}
	catch (COleException* e)
	{
		TCHAR szCause[255];
		CString strFormatted;
		e->GetErrorMessage(szCause, 255);
		ZTools::WriteZToolsFormatLog("PRC组件调用异常,%s", szCause);
		return "";
	}
	catch (CException* e)
	{
		TCHAR szCause[255];
		CString strFormatted;
		e->GetErrorMessage(szCause, 255);
		ZTools::WriteZToolsFormatLog("RPC组件调用异常,%s", szCause);
		return "";
	}
	if (SUCCEEDED(hr))
	{
		::CoUninitialize();
	}
	return sResult;
}