BOOL CConverter::Open(LPCTSTR pszFileName, UINT nOpenFlags,
CFileException* pException)
{
USES_CONVERSION;
// we convert to oem and back because of the following case
// test(c).txt becomes testc.txt in OEM and stays testc.txt to Ansi
char buf[_MAX_PATH];
strcpy(buf, T2CA(pszFileName));
CharToOemA(buf, buf);
OemToCharA(buf, buf);
LPTSTR lpszFileNameT = A2T(buf);
// let's make sure we could do what is wanted directly even though we aren't
m_bCloseOnDelete = FALSE;
#if _MSC_VER >= 1400
m_hFile = hFileNull;
#else
m_hFile = (UINT)hFileNull;
#endif
BOOL bOpen = CFile::Open(lpszFileNameT, nOpenFlags, pException);
CFile::Close();
if (!bOpen)
return FALSE;
m_bForeignToRtf = !(nOpenFlags & (CFile::modeReadWrite | CFile::modeWrite));
// check for reading empty file
if (m_bForeignToRtf)
{
CFileStatus stat;
if (CFile::GetStatus(lpszFileNameT, stat) && stat.m_size == 0)
return TRUE;
}
//set security attributes to inherit handle
SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
//create the events
m_hEventFile = CreateEvent(&sa, TRUE, FALSE, NULL);
m_hEventConv = CreateEvent(&sa, TRUE, FALSE, NULL);
//create the converter thread and create the events
CharToOemA(buf, buf);
ASSERT(m_hFileName == NULL);
m_hFileName = StringToHGLOBAL(buf);
m_pThis = this;
m_bDone = FALSE;
m_hBuff = GlobalAlloc(GHND, BUFFSIZE);
ASSERT(m_hBuff != NULL);
AfxBeginThread(ConverterThread, this, THREAD_PRIORITY_NORMAL, 0, 0, &sa);
return TRUE;
}
static void cvt_wprintf(FILE *dest,const wchar *fmt,va_list arglist)
{
// This buffer is for format string only, not for entire output,
// so it can be short enough.
wchar fmtw[1024];
PrintfPrepareFmt(fmt,fmtw,ASIZE(fmtw));
#ifdef _WIN_ALL
safebuf wchar Msg[MaxMsgSize];
if (dest==stdout && StdoutRedirected || dest==stderr && StderrRedirected)
{
// Avoid Unicode for redirect in Windows, it does not work with pipes.
vswprintf(Msg,ASIZE(Msg),fmtw,arglist);
safebuf char MsgA[MaxMsgSize];
WideToChar(Msg,MsgA,ASIZE(MsgA));
CharToOemA(MsgA,MsgA); // Console tools like 'more' expect OEM encoding.
// We already converted \n to \r\n above, so we use WriteFile instead
// of C library to avoid unnecessary additional conversion.
HANDLE hOut=GetStdHandle(dest==stdout ? STD_OUTPUT_HANDLE:STD_ERROR_HANDLE);
DWORD Written;
WriteFile(hOut,MsgA,(DWORD)strlen(MsgA),&Written,NULL);
return;
}
// MSVC2008 vfwprintf writes every character to console separately
// and it is too slow. We use direct WriteConsole call instead.
vswprintf(Msg,ASIZE(Msg),fmtw,arglist);
HANDLE hOut=GetStdHandle(dest==stderr ? STD_ERROR_HANDLE:STD_OUTPUT_HANDLE);
DWORD Written;
WriteConsole(hOut,Msg,(DWORD)wcslen(Msg),&Written,NULL);
#else
vfwprintf(dest,fmtw,arglist);
// We do not use setbuf(NULL) in Unix (see comments in InitConsole).
fflush(dest);
#endif
}
void ExtToInt(const char *Src,char *Dest)
{
#ifdef _WIN_ALL
CharToOemA(Src,Dest);
#else
if (Dest!=Src)
strcpy(Dest,Src);
#endif
}
void printStringToConsole(const char* format, const QString& str){
QByteArray ba = str.toLocal8Bit();
char* buf = ba.data();
#ifdef Q_OS_WIN32
// a bit of magic to workaround Windows console encoding issues
CharToOemA(buf,buf);
#endif
printf(format, buf);
}
void LocalUpperInit()
{
for (unsigned int I=0; I<ARRAYSIZE(LowerToUpper); I++)
{
char CvtStr[]={I,L'\0'},ReverseCvtStr[2];
LowerToUpper[I]=UpperToLower[I]=I;
OemToCharA(CvtStr,CvtStr);
CharToOemA(CvtStr,ReverseCvtStr);
IsUpperOrLower[I]=0;
if (IsCharAlphaA(CvtStr[0]) && ReverseCvtStr[0]==static_cast<char>(I))
{
IsUpperOrLower[I]=IsCharLowerA(CvtStr[0])?1:(IsCharUpperA(CvtStr[0])?2:0);
CharUpperA(CvtStr);
CharToOemA(CvtStr,CvtStr);
LowerToUpper[I]=CvtStr[0];
CvtStr[0]=I;
OemToCharA(CvtStr,CvtStr);
CharLowerA(CvtStr);
CharToOemA(CvtStr,CvtStr);
UpperToLower[I]=CvtStr[0];
}
}
}
LPCSTR CConvOem::toOemA(LPCSTR const lpszSrc)
{
if (m_blInvalidBuff || !lpszSrc)
{
SetLastError(ERROR_INVALID_ADDRESS);
return 0;
}
size_t len(strlen(lpszSrc)); len++;
if (len > m_BuffSize)
{
SetLastError(ERROR_INVALID_ADDRESS);
return 0;
}
CharToOemA(lpszSrc, m_szBuff);
return m_szBuff;
}
void main(void)
{
FILE* in;
int ch;
static char string[2];
if ((in = fopen("test.txt", "r")) != NULL)
{
while ((ch = getc(in)) != EOF)
{
*string = ch;
CharToOemA(string, string);
ch = *string;
putc(ch, stdout);
}
fclose(in);
}
else
printf("Нет возможности открыть файл. \n");
}
BOOL CConverter::IsFormatCorrect(LPCTSTR pszFileName)
{
USES_CONVERSION;
int nRet;
if (m_hLibCnv == NULL || m_pIsFormatCorrect == NULL)
return FALSE;
char buf[_MAX_PATH];
strcpy(buf, T2CA(pszFileName));
CharToOemA(buf, buf);
HGLOBAL hFileName = StringToHGLOBAL(buf);
HGLOBAL hDesc = GlobalAlloc(GHND, 256);
ASSERT(hDesc != NULL);
nRet = m_pIsFormatCorrect(hFileName, hDesc);
GlobalFree(hDesc);
GlobalFree(hFileName);
return (nRet == 1) ? TRUE : FALSE;
}
void LogCacheExt::onMessage(const LogMessage& msg) {
if (!filter.isEmpty() && !filter.matches(msg)) {
return;
}
if (consoleEnabled){
QByteArray ba = msg.text.toLocal8Bit();
char* buf = ba.data();
#ifdef Q_OS_WIN32
// a bit of magic to workaround Windows console encoding issues
CharToOemA(buf,buf);
#endif
printf("%s\n", buf);
}
if (fileEnabled) {
QByteArray ba = msg.text.toLocal8Bit();
char* buf = ba.data();
file.write(buf, ba.length());
file.write("\n", 1);
file.flush();
}
LogCache::onMessage(msg);
}
/***********************************************************************
* AnsiToOem (KEYBOARD.5)
*/
INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
{
CharToOemA( s, d );
return -1;
}
int PASCAL RARReadHeaderEx(HANDLE hArcData,struct RARHeaderDataEx *D)
{
DataSet *Data=(DataSet *)hArcData;
try
{
if ((Data->HeaderSize=(int)Data->Arc.SearchBlock(HEAD_FILE))<=0)
{
if (Data->Arc.Volume && Data->Arc.GetHeaderType()==HEAD_ENDARC &&
Data->Arc.EndArcHead.NextVolume)
if (MergeArchive(Data->Arc,NULL,false,'L'))
{
Data->Arc.Seek(Data->Arc.CurBlockPos,SEEK_SET);
return RARReadHeaderEx(hArcData,D);
}
else
return ERAR_EOPEN;
if (Data->Arc.BrokenHeader)
return ERAR_BAD_DATA;
// Might be necessary if RARSetPassword is still called instead of
// open callback for RAR5 archives and if password is invalid.
if (Data->Arc.FailedHeaderDecryption)
return ERAR_BAD_PASSWORD;
return ERAR_END_ARCHIVE;
}
FileHeader *hd=&Data->Arc.FileHead;
if (Data->OpenMode==RAR_OM_LIST && hd->SplitBefore)
{
int Code=RARProcessFile(hArcData,RAR_SKIP,NULL,NULL);
if (Code==0)
return RARReadHeaderEx(hArcData,D);
else
return Code;
}
wcsncpy(D->ArcNameW,Data->Arc.FileName,ASIZE(D->ArcNameW));
WideToChar(D->ArcNameW,D->ArcName,ASIZE(D->ArcName));
wcsncpy(D->FileNameW,hd->FileName,ASIZE(D->FileNameW));
WideToChar(D->FileNameW,D->FileName,ASIZE(D->FileName));
#ifdef _WIN_ALL
CharToOemA(D->FileName,D->FileName);
#endif
D->Flags=0;
if (hd->SplitBefore)
D->Flags|=RHDF_SPLITBEFORE;
if (hd->SplitAfter)
D->Flags|=RHDF_SPLITAFTER;
if (hd->Encrypted)
D->Flags|=RHDF_ENCRYPTED;
if (hd->Solid)
D->Flags|=RHDF_SOLID;
if (hd->Dir)
D->Flags|=RHDF_DIRECTORY;
D->PackSize=uint(hd->PackSize & 0xffffffff);
D->PackSizeHigh=uint(hd->PackSize>>32);
D->UnpSize=uint(hd->UnpSize & 0xffffffff);
D->UnpSizeHigh=uint(hd->UnpSize>>32);
D->HostOS=hd->HSType==HSYS_WINDOWS ? HOST_WIN32:HOST_UNIX;
if (Data->Arc.Format==RARFMT50)
D->UnpVer=Data->Arc.FileHead.UnpVer==0 ? 50 : 200; // If it is not 0, just set it to something big.
else
D->UnpVer=Data->Arc.FileHead.UnpVer;
D->FileCRC=hd->FileHash.CRC32;
D->FileTime=hd->mtime.GetDos();
D->Method=hd->Method+0x30;
D->FileAttr=hd->FileAttr;
D->CmtSize=0;
D->CmtState=0;
D->DictSize=uint(hd->WinSize/1024);
switch (hd->FileHash.Type)
{
case HASH_RAR14:
case HASH_CRC32:
D->HashType=RAR_HASH_CRC32;
break;
case HASH_BLAKE2:
D->HashType=RAR_HASH_BLAKE2;
memcpy(D->Hash,hd->FileHash.Digest,BLAKE2_DIGEST_SIZE);
break;
default:
D->HashType=RAR_HASH_NONE;
break;
}
}
catch (RAR_EXIT ErrCode)
{
return Data->Cmd.DllError!=0 ? Data->Cmd.DllError : RarErrorToDll(ErrCode);
}
return ERAR_SUCCESS;
}
char* Rus(const char* text)
{
CharToOemA(text, bufRus);
return bufRus;
}
string Tooem(const char* str) //нужно для распознавания русского названия файлов из консоли
{
vector<char> buffer(strlen(str) + 1);
CharToOemA(str, &buffer[0]); //конвертация char в string
return string(&buffer[0], buffer.size()-1);
}
/*************************************************************************
* DoEnvironmentSubst [SHELL.37]
*
* Replace %KEYWORD% in the str with the value of variable KEYWORD
* from "DOS" environment. If it is not found the %KEYWORD% is left
* intact. If the buffer is too small, str is not modified.
*
* PARAMS
* str [I] '\0' terminated string with %keyword%.
* [O] '\0' terminated string with %keyword% substituted.
* length [I] size of str.
*
* RETURNS
* str length in the LOWORD and 1 in HIWORD if subst was successful.
*/
DWORD WINAPI DoEnvironmentSubst16(LPSTR str,WORD length)
{
LPSTR lpEnv = MapSL(GetDOSEnvironment16());
LPSTR lpstr = str;
LPSTR lpend;
LPSTR lpBuffer = HeapAlloc( GetProcessHeap(), 0, length);
WORD bufCnt = 0;
WORD envKeyLen;
LPSTR lpKey;
WORD retStatus = 0;
WORD retLength = length;
CharToOemA(str,str);
TRACE("accept %s\n", str);
while( *lpstr && bufCnt <= length - 1 ) {
if ( *lpstr != '%' ) {
lpBuffer[bufCnt++] = *lpstr++;
continue;
}
for( lpend = lpstr + 1; *lpend && *lpend != '%'; lpend++) /**/;
envKeyLen = lpend - lpstr - 1;
if( *lpend != '%' || envKeyLen == 0)
goto err; /* "%\0" or "%%" found; back off and whine */
*lpend = '\0';
lpKey = SHELL_FindString(lpEnv, lpstr+1);
*lpend = '%';
if( lpKey ) {
int l = strlen(lpKey);
if( bufCnt + l > length - 1 )
goto err;
memcpy(lpBuffer + bufCnt, lpKey, l);
bufCnt += l;
} else { /* Keyword not found; Leave the %KEYWORD% intact */
if( bufCnt + envKeyLen + 2 > length - 1 )
goto err;
memcpy(lpBuffer + bufCnt, lpstr, envKeyLen + 2);
bufCnt += envKeyLen + 2;
}
lpstr = lpend + 1;
}
if (!*lpstr && bufCnt <= length - 1) {
memcpy(str,lpBuffer, bufCnt);
str[bufCnt] = '\0';
retLength = bufCnt + 1;
retStatus = 1;
}
err:
if (!retStatus)
WARN("-- Env subst aborted - string too short or invalid input\n");
TRACE("-- return %s\n", str);
OemToCharA(str,str);
HeapFree( GetProcessHeap(), 0, lpBuffer);
return (DWORD)MAKELONG(retLength, retStatus);
}
/*************************************************************************
* DoEnvironmentSubst [SHELL.37]
*
* Replace %KEYWORD% in the str with the value of variable KEYWORD
* from "DOS" environment.
*/
DWORD WINAPI DoEnvironmentSubst16(LPSTR str,WORD length)
{
LPSTR lpEnv = MapSL(GetDOSEnvironment16());
LPSTR lpBuffer = (LPSTR)HeapAlloc( GetProcessHeap(), 0, length);
LPSTR lpstr = str;
LPSTR lpbstr = lpBuffer;
CharToOemA(str,str);
TRACE("accept %s\n", str);
while( *lpstr && lpbstr - lpBuffer < length )
{
LPSTR lpend = lpstr;
if( *lpstr == '%' )
{
do { lpend++; } while( *lpend && *lpend != '%' );
if( *lpend == '%' && lpend - lpstr > 1 ) /* found key */
{
LPSTR lpKey;
*lpend = '\0';
lpKey = SHELL_FindString(lpEnv, lpstr+1);
if( lpKey ) /* found key value */
{
int l = strlen(lpKey);
if( l > length - (lpbstr - lpBuffer) - 1 )
{
WARN("-- Env subst aborted - string too short\n");
*lpend = '%';
break;
}
strcpy(lpbstr, lpKey);
lpbstr += l;
}
else break;
*lpend = '%';
lpstr = lpend + 1;
}
else break; /* back off and whine */
continue;
}
*lpbstr++ = *lpstr++;
}
*lpbstr = '\0';
if( lpstr - str == strlen(str) )
{
strncpy(str, lpBuffer, length);
length = 1;
}
else
length = 0;
TRACE("-- return %s\n", str);
OemToCharA(str,str);
HeapFree( GetProcessHeap(), 0, lpBuffer);
/* Return str length in the LOWORD
* and 1 in HIWORD if subst was successful.
*/
return (DWORD)MAKELONG(strlen(str), length);
}
