static int ansi_emulate_write(int fd, const void *buf, size_t count)
{
int rv = 0, i;
const char *s = (const char *)buf;
char *pos, *str;
size_t len, out_len;
static size_t max_len = 0;
static char *mem = NULL;
/* if no special treatment is required output the string as-is */
for ( i=0; i<count; ++i ) {
if ( s[i] == '\033' || s[i] > 0x7f ) {
break;
}
}
if ( i == count ) {
return write(fd, buf, count);
}
/* make a writable copy of the data and retain it for reuse */
if ( count > max_len ) {
free(mem);
mem = malloc(count+1);
max_len = count;
}
memcpy(mem, buf, count);
mem[count] = '\0';
pos = str = mem;
/* we're writing to the console so we assume the data isn't binary */
while (*pos) {
pos = strstr(str, "\033[");
if (pos) {
len = pos - str;
if (len) {
CharToOemBuff(str, str, len);
out_len = write(fd, str, len);
rv += out_len;
if (out_len < len)
return rv;
}
str = pos + 2;
rv += 2;
pos = (char *)set_attr(str);
rv += pos - str;
str = pos;
} else {
len = strlen(str);
rv += len;
CharToOem(str, str);
write(fd, str, len);
return rv;
}
}
return rv;
}
void NCursesFrontend::PlotText(const char * string, int row, int pos, int colorPair, bool blink)
{
#ifdef WIN32
int bufPos = row * m_screenWidth + pos;
int len = strlen(string);
for (int i = 0; i < len; i++)
{
char c = string[i];
CharToOemBuff(&c, &c, 1);
m_screenBuffer[bufPos + i].Char.AsciiChar = c;
m_screenBuffer[bufPos + i].Attributes = m_colorAttr[colorPair];
}
#else
if( m_useColor )
{
attron(COLOR_PAIR(colorPair));
if (blink)
{
attron(A_BLINK);
}
}
mvaddstr(row, pos, (char*)string);
if( m_useColor )
{
attroff(COLOR_PAIR(colorPair));
if (blink)
{
attroff(A_BLINK);
}
}
#endif
}
int lpprintf(const char *format, ...)
{
va_list va;
va_start(va, format);
const int MAX_SIZE = 16192;
char buffer[MAX_SIZE] = {0};
int len = mir_vsnprintf(buffer, MAX_SIZE - 1, format, va);
buffer[MAX_SIZE - 1] = 0;
va_end(va);
CharToOemBuff(buffer, buffer, len);
printf("%s", buffer);
return len;
}
/************************** procesa_argumentos ******************************
Función para procesar los argumentos de la línea de comandos.
- Primero es el nombre (y el camino) del directorio de patrones.
- Segundo es el nombre (y el camino) del directorio donde guardar las imagenes.
*****************************************************************************/
bool procesa_argumentos(int argc, TCHAR* argv[])
{
char mensaje[1024];
char *fn = "procesa_argumentos";
if (argc != 2 && argc != 6 ) {
sprintf(mensaje,
"\a ERROR. Numero incorrecto de argumentos\n"
"\t Uso: ComponerMosaico.exe directorio_barrido - se intentará componer el mosaico con el barrido completo\n"
"\t Uso alternativo: ComponerMosaico.exe directorio_barrido fila_inicio columna_inicio fila_final columna final\n");
CharToOemBuff(mensaje, mensaje, sizeof(mensaje));
fprintf(stderr, "\n%s", mensaje);
getch();
return false;
}
//El segundo argumento es el directorio de trabajo
g_csDirectorioBarrido = argv[1];
if (argc == 6)
{
g_nFilaInicio = atoi(argv[2]);
g_nColumnaInicio = atoi(argv[3]);
g_nFilaFin = atoi(argv[4]);
g_nColumnaFin = atoi(argv[5]);
// Comprobaciones
if ( g_nFilaInicio > g_nFilaFin || g_nFilaInicio < 1 ||
g_nColumnaInicio > g_nColumnaFin || g_nColumnaInicio < 1 )
{
printf("Error: Inicio de mosaico fuera de limites \n");
return false;
}
}
else
{
g_nFilaInicio = -1;
g_nColumnaInicio = -1;
g_nFilaFin = -1;
g_nColumnaFin = -1;
}
// El argumento de la linea de comandos es el directorio de patrones.
// return argv[1];
return true;
}
int winansi_putchar(int c)
{
char t = c;
char *s = &t;
if (!isatty(STDOUT_FILENO))
return putchar(c);
init();
if (!console)
return putchar(c);
CharToOemBuff(s, s, 1);
return putchar(t) == EOF ? EOF : c;
}
int GetCharTable(int i, struct CharTableSet *cts)
{
if (i>1)
return Info.CharTable(i-2,(char *)cts,sizeof(struct CharTableSet));
else
{
for (int j=0; j<256; j++)
cts->DecodeTable[j] = cts->EncodeTable[j] = (unsigned char) j;
if (i == 1)
{
OemToCharBuff((const CHAR *)cts->DecodeTable,(CHAR *)cts->EncodeTable,256);
CharToOemBuff((const CHAR *)cts->DecodeTable,(CHAR *)cts->DecodeTable,256);
lstrcpy(cts->TableName,GetMsg(MWinText));
}
else
lstrcpy(cts->TableName,GetMsg(MDosText));
}
return i;
}
/************************** procesa_argumentos ******************************
Función para procesar los argumentos de la línea de comandos.
- Primero es el directorio donde buscar (recursivamente) los ficheros de entrada
- Segundo es el nombre (y el camino) del fichero de salida
*****************************************************************************/
bool procesa_argumentos(int argc, TCHAR* argv[], CString& csDirectorioEntrada, CString& csFicheroSalida)
{
char mensaje[1024];
char *fn = "procesa_argumentos";
if (argc <= 2) {
sprintf(mensaje,
"\a RecopilaDatos busca en un directorio ficheros con información espectral.\n"
"\a y los compila en un archivo único de salida .\n"
"\t Uso: RecopilaDados.exe directorio_busqueda fichero_salida\n");
CharToOemBuff(mensaje, mensaje, sizeof(mensaje));
fprintf(stderr, "\n%s", mensaje);
Sleep(3000); // Espera para leer el mensaje que aparece en consola
return false;
}
/* El argumento de la linea de comandos es el directorio de patrones. */
csDirectorioEntrada = argv[1];
csFicheroSalida = argv[2];
return true;
}
void CryptData::SetCryptKeys(char *Password,unsigned char *Salt,bool Encrypt,bool OldOnly)
{
if (*Password==0)
return;
if (OldOnly)
{
#ifndef SFX_MODULE
if (CRCTab[1]==0)
InitCRC();
unsigned char Psw[MAXPASSWORD];
SetOldKeys(Password);
Key[0]=0xD3A3B879L;
Key[1]=0x3F6D12F7L;
Key[2]=0x7515A235L;
Key[3]=0xA4E7F123L;
memset(Psw,0,sizeof(Psw));
#if defined(_WIN_32) && !defined(GUI)
CharToOemBuff(Password,(char*)Psw,strlen(Password));
#else
strncpy((char *)Psw,Password,MAXPASSWORD-1);
#endif
int PswLength=strlen(Password);
memcpy(SubstTable,InitSubstTable,sizeof(SubstTable));
for (int J=0;J<256;J++)
for (int I=0;I<PswLength;I+=2)
{
unsigned int N1=(unsigned char)CRCTab[(Psw[I]-J)&0xff];
unsigned int N2=(unsigned char)CRCTab[(Psw[I+1]+J)&0xff];
for (int K=1;N1!=N2;N1=(N1+1)&0xff,K++)
Swap(&SubstTable[N1],&SubstTable[(N1+I+K)&0xff]);
}
for (int I=0;I<PswLength;I+=16)
EncryptBlock20(&Psw[I]);
#endif
return;
}
bool Cached=false;
for (int I=0;I<sizeof(Cache)/sizeof(Cache[0]);I++)
if (strcmp(Cache[I].Password,Password)==0 &&
(Salt==NULL && !Cache[I].SaltPresent || Salt!=NULL &&
Cache[I].SaltPresent && memcmp(Cache[I].Salt,Salt,SALT_SIZE)==0))
{
memcpy(AESKey,Cache[I].AESKey,sizeof(AESKey));
memcpy(AESInit,Cache[I].AESInit,sizeof(AESInit));
Cached=true;
break;
}
if (!Cached)
{
wchar PswW[MAXPASSWORD];
CharToWide(Password,PswW,MAXPASSWORD-1);
PswW[MAXPASSWORD-1]=0;
unsigned char RawPsw[2*MAXPASSWORD+SALT_SIZE];
WideToRaw(PswW,RawPsw);
int RawLength=2*strlenw(PswW);
if (Salt!=NULL)
{
memcpy(RawPsw+RawLength,Salt,SALT_SIZE);
RawLength+=SALT_SIZE;
}
hash_context c;
hash_initial(&c);
const int HashRounds=0x40000;
for (int I=0;I<HashRounds;I++)
{
hash_process( &c, RawPsw, RawLength);
unsigned char PswNum[3];
PswNum[0]=(unsigned char)I;
PswNum[1]=(unsigned char)(I>>8);
PswNum[2]=(unsigned char)(I>>16);
hash_process( &c, PswNum, 3);
if (I%(HashRounds/16)==0)
{
hash_context tempc=c;
uint32 digest[5];
hash_final( &tempc, digest);
AESInit[I/(HashRounds/16)]=(unsigned char)digest[4];
}
}
uint32 digest[5];
hash_final( &c, digest);
for (int I=0;I<4;I++)
for (int J=0;J<4;J++)
AESKey[I*4+J]=(unsigned char)(digest[I]>>(J*8));
strcpy(Cache[CachePos].Password,Password);
if ((Cache[CachePos].SaltPresent=(Salt!=NULL))==true)
memcpy(Cache[CachePos].Salt,Salt,SALT_SIZE);
memcpy(Cache[CachePos].AESKey,AESKey,sizeof(AESKey));
memcpy(Cache[CachePos].AESInit,AESInit,sizeof(AESInit));
CachePos=(CachePos+1)%(sizeof(Cache)/sizeof(Cache[0]));
}
FarString FarString::ToOEM() const
{
FarString result (fData->fText, Length());
CharToOemBuff (fData->fText, result.GetBuffer(), Length());
return result;
}
BYTE* dataparser2(LPCWSTR pStr,DWORD* pdwDataLength)
{
if (pStr[0]=='\0')
return NULL;
BYTE* pData=new BYTE[10];
BYTE* pDataPtr=pData;
DWORD nAllocLen=10;
// Removing spaces
while (*pStr==' ') pStr++;
while (*pStr!='\0')
{
if (_1stcontain2nd(pStr,L"int"))
{
pStr+=3;
int base=_getbase2(pStr,10);
if (*pStr!='(')
break;
pStr++;
_allocmore(pData,pDataPtr,nAllocLen,4);
*((DWORD*)pDataPtr)=DWORD(_readnum(base,pStr));
while (*pStr!=')' && *pStr!='\0') pStr++;
if (*pStr==')') pStr++;
pDataPtr+=4;
}
else if (_1stcontain2nd(pStr,L"dword"))
{
pStr+=5;
int base=_getbase2(pStr,16);
if (*pStr!='(')
break;
pStr++;
_allocmore(pData,pDataPtr,nAllocLen,4);
*((DWORD*)pDataPtr)=DWORD(_readnum(base,pStr));
while (*pStr!=')' && *pStr!='\0') pStr++;
if (*pStr==')') pStr++;
pDataPtr+=4;
}
else if (_1stcontain2nd(pStr,L"word"))
{
pStr+=4;
int base=_getbase2(pStr,16);
if (*pStr!='(')
break;
pStr++;
_allocmore(pData,pDataPtr,nAllocLen,2);
*((WORD*)pDataPtr)=WORD(_readnum(base,pStr));
while (*pStr!=')' && *pStr!='\0') pStr++;
if (*pStr==')') pStr++;
pDataPtr+=2;
}
else if (_1stcontain2nd(pStr,L"byte"))
{
pStr+=4;
int base=_getbase2(pStr,16);
if (*pStr!='(')
break;
pStr++;
_allocmore(pData,pDataPtr,nAllocLen,1);
*((BYTE*)pDataPtr)=BYTE(_readnum(base,pStr));
while (*pStr!=')' && *pStr!='\0') pStr++;
if (*pStr==')') pStr++;
pDataPtr+=1;
}
else if (_1stcontain2nd(pStr,L"str"))
{
pStr+=3;
if (*pStr!='(')
break;
pStr++;
for (;*pStr!=')' && *pStr!='\0';pStr++)
{
_allocmore(pData,pDataPtr,nAllocLen,1);
if (*pStr=='\\' && pStr[1]!='\0')
{
pStr++;
switch (*pStr)
{
case '0':
*(pDataPtr++)='\0';
break;
case 'n':
*(pDataPtr++)='\n';
break;
case 'r':
*(pDataPtr++)='\r';
break;
case 't':
*(pDataPtr++)='\t';
break;
case 'b':
*(pDataPtr++)='\b';
break;
case ')':
*(pDataPtr++)=')';
break;
default:
*(pDataPtr++)=BYTE(_readnum(16,pStr,2));;
pStr--;
break;
}
}
else
*(pDataPtr++)=W2Ac(*pStr);
}
if (*pStr==')') pStr++;
}
else if (_1stcontain2nd(pStr,L"oem"))
{
pStr+=3;
if (*pStr!='(')
break;
pStr++;
int iStart=DWORD(pDataPtr-pData);
for (;*pStr!=')' && *pStr!='\0';pStr++)
{
_allocmore(pData,pDataPtr,nAllocLen,1);
if (*pStr=='\\' && pStr[1]!='\0')
{
pStr++;
switch (*pStr)
{
case '0':
*(pDataPtr++)='\0';
break;
case 'n':
*(pDataPtr++)='\n';
break;
case 'r':
*(pDataPtr++)='\r';
break;
case 't':
*(pDataPtr++)='\t';
break;
case 'b':
*(pDataPtr++)='\b';
break;
case ')':
*(pDataPtr++)=')';
break;
default:
*(pDataPtr++)=BYTE(_readnum(16,pStr,2));;
pStr--;
break;
}
}
else
*(pDataPtr++)=W2Ac(*pStr);
}
CharToOemBuff(LPSTR(pData+iStart),LPSTR(pData+iStart),DWORD(pDataPtr-pData)-iStart);
if (*pStr==')') pStr++;
}
else if (_1stcontain2nd(pStr,L"wstr") || _1stcontain2nd(pStr,L"uni"))
{
pStr+=3;
while (*pStr!='(') pStr++;
pStr++;
for (;*pStr!=')' && *pStr!='\0';pStr++)
{
_allocmore(pData,pDataPtr,nAllocLen,2);
if (*pStr=='\\' && pStr[1]!='\0')
{
pStr++;
switch (*pStr)
{
case '0':
*LPWORD(pDataPtr)=L'\0';
break;
case 'n':
*LPWORD(pDataPtr)=L'\n';
break;
case 'r':
*LPWORD(pDataPtr)=L'\r';
break;
case 't':
*LPWORD(pDataPtr)=L'\t';
break;
case 'b':
*LPWORD(pDataPtr)=L'\b';
break;
case ')':
*LPWORD(pDataPtr)=L')';
break;
default:
*LPWORD(pDataPtr)=WORD(_readnum(16,pStr,4));;
pStr--;
break;
}
pDataPtr+=2;
}
else
{
*((WCHAR*)pDataPtr)=*pStr;
pDataPtr+=2;
}
}
if (*pStr==')')
pStr++;
}
else
{
_allocmore(pData,pDataPtr,nAllocLen,1);
LPCWSTR pStrOld=pStr;
*pDataPtr=_readnum(16,pStr,2);
if (pStr==pStrOld)
{
*pdwDataLength=DWORD(pDataPtr-pData);
return pData;
}
pDataPtr++;
}
while (*pStr==' ') pStr++;
}
*pdwDataLength=DWORD(pDataPtr-pData);
return pData;
}
static int ansi_emulate(const char *s, FILE *stream)
{
int rv = 0;
const char *t;
char *pos, *str;
size_t out_len, cur_len;
static size_t max_len = 0;
static char *mem = NULL;
/* if no special treatment is required output the string as-is */
for ( t=s; *t; ++t ) {
if ( *t == '\033' || *t > 0x7f ) {
break;
}
}
if ( *t == '\0' ) {
return fputs(s, stream) == EOF ? EOF : strlen(s);
}
/* make a writable copy of the string and retain it for reuse */
cur_len = strlen(s);
if ( cur_len == 0 || cur_len > max_len ) {
free(mem);
mem = strdup(s);
max_len = cur_len;
}
else {
strcpy(mem, s);
}
pos = str = mem;
while (*pos) {
pos = strstr(str, "\033[");
if (pos) {
size_t len = pos - str;
if (len) {
CharToOemBuff(str, str, len);
out_len = fwrite(str, 1, len, stream);
rv += out_len;
if (out_len < len)
return rv;
}
str = pos + 2;
rv += 2;
fflush(stream);
pos = (char *)set_attr(str);
rv += pos - str;
str = pos;
} else {
rv += strlen(str);
CharToOem(str, str);
fputs(str, stream);
return rv;
}
}
return rv;
}
void CEditWnd::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
CTextWnd::OnChar(nChar, nRepCnt, nFlags);
if (m_bOemCharset) CharToOemBuff((char*)&nChar, (char*)&nChar, 1);
if ((::GetAsyncKeyState(VK_LBUTTON) | ::GetAsyncKeyState(VK_RBUTTON)) & 0x8000) return;
BOOL bTranslated = FALSE;
if (nChar == VK_RETURN)
{
m_pTextBuffer->BeginUndoGroup();
if (QueryEditable() && m_pTextBuffer != NULL)
{
DeleteCurrentSelection();
CPoint ptCursorPos = GetCursorPos();
ASSERT_VALIDTEXTPOS(ptCursorPos);
int x, y;
CString pszText = "\r\n";
bool flag;
if (ptCursorPos.x > 0)
{
LPCSTR chars1 = GetLineChars(ptCursorPos.y);
char *p = 0;
for (int j = 0; j < QUOTE_LENGTH && j < GetLineLength(ptCursorPos.y); j++)
if (chars1[j] == '>') p = (char*)chars1 + j;
flag = p != 0 && ptCursorPos.x < GetLineLength(ptCursorPos.y);
//Вставим знаки квоты
if (flag)
{
p++;
while (isspace((unsigned char)*p)) p++;
pszText += CString(chars1, (int)(p - chars1));
}
//Автоотступ
else if (m_bAutoIndent)
{
LPCSTR chars = m_pTextBuffer->GetLineChars(ptCursorPos.y);
int len = m_pTextBuffer->GetLineLength(ptCursorPos.y);
for (int j = 0; j < len && isspace((unsigned char)chars[j]); j++) pszText += chars[j];
}
}
else flag = false;
m_pTextBuffer->InsertText(this, ptCursorPos.y, ptCursorPos.x, pszText, y, x, CE_ACTION_TYPING);
ptCursorPos.x = flag ? 0 : x;
ptCursorPos.y = y;
ASSERT_VALIDTEXTPOS(ptCursorPos);
SetSelection(ptCursorPos, ptCursorPos);
SetAnchor(ptCursorPos);
SetCursorPos(ptCursorPos);
EnsureVisible(ptCursorPos);
}
m_pTextBuffer->FlushUndoGroup(this);
return;
}
else if (nChar > 31)
{
if (QueryEditable() && m_pTextBuffer != NULL)
{
m_pTextBuffer->BeginUndoGroup(nChar != _T(' '));
CPoint ptSelStart, ptSelEnd;
GetSelection(ptSelStart, ptSelEnd);
CPoint ptCursorPos;
if (ptSelStart != ptSelEnd)
{
ptCursorPos = ptSelStart;
DeleteCurrentSelection();
}
else
ptCursorPos = GetCursorPos();
ASSERT_VALIDTEXTPOS(ptCursorPos);
char pszText[2];
pszText[0] = (char) nChar;
pszText[1] = 0;
int x, y;
m_pTextBuffer->InsertText(this, ptCursorPos.y, ptCursorPos.x, pszText, y, x, CE_ACTION_TYPING); // [JRT]
ptCursorPos.x = x;
ptCursorPos.y = y;
ASSERT_VALIDTEXTPOS(ptCursorPos);
SetSelection(ptCursorPos, ptCursorPos);
SetAnchor(ptCursorPos);
SetCursorPos(ptCursorPos);
EnsureVisible(ptCursorPos);
m_pTextBuffer->FlushUndoGroup(this);
}
}
}
/* ********************************************************************************************** */
int WINAPI _tWinMain(HINSTANCE instance, HINSTANCE previousInstance, LPTSTR commandLine,
int showCommand)
{
int argc;
LPWSTR *argv = CommandLineToArgvW(GetCommandLine(), &argc);
if(argc > 2)
{
MessageBox(NULL, _T("CreepWrap accepts a single, optional, argument, which should be the ")
_T("path to Minecraft.exe.\n\nIn the absence of this argument, CreepWrap will ")
_T("attempt to load Minecraft.exe from the current working directory."),
_T("CreepWrap usage"), MB_ICONWARNING | MB_OK);
return 1;
}
try
{
jvminvoke::JavaVM javaVM;
const std::string mainClass("net/minecraft/LauncherFrame");
if(argc == 1)
{
javaVM.executeJAR("Minecraft.exe", mainClass);
}
else
{
LPSTR jarPathBuffer = static_cast<LPSTR>(std::malloc((std::wcslen(argv[1]) + 1) *
sizeof(char)));
jarPathBuffer[std::wcslen(argv[1])] = '\0';
CharToOemBuff(argv[1], jarPathBuffer, static_cast<DWORD>(std::wcslen(argv[1])));
std::string jarPath(jarPathBuffer);
std::free(jarPathBuffer);
javaVM.executeJAR(jarPath, mainClass);
}
}
catch(const jvminvoke::JavaException &e)
{
std::wstring message = e.wideMessage() + L"\n\nJava exception details:\n" + e.javaMessage();
MessageBoxW(NULL, message.c_str(), L"Error", MB_ICONERROR | MB_OK);
return -2;
}
catch(const jvminvoke::RuntimeException &e)
{
MessageBoxA(NULL, e.message().c_str(), "Error", MB_ICONERROR | MB_OK);
return e.returnCode();
}
catch(const jvminvoke::Exception &e)
{
MessageBoxA(NULL, e.message().c_str(), "Error", MB_ICONERROR | MB_OK);
return -1;
}
return 0;
} // _tWinMain
//------------------------------------------------------------------------
void WINAPI ReadCfg(void)
{
char str[ FAR_MAX_NAME ],*m;
int val,n;
#define GCMD( fnm,nm,v ) FP_GetRegKey( fnm,Opt.v,nm,ARRAYSIZE(Opt.v) ); if (TrimLen(Opt.v) == 0) strcpy( Opt.v,nm );
Opt.AddToDisksMenu = FP_GetRegKey("AddToDisksMenu", 1);
Opt.AddToPluginsMenu = FP_GetRegKey("AddToPluginsMenu", 1);
Opt.DisksMenuDigit = FP_GetRegKey("DisksMenuDigit", 2);
Opt.ReadDescriptions = FP_GetRegKey("ReadDescriptions", 0);
Opt.UploadLowCase = FP_GetRegKey("UploadLowCase", 0);
Opt.ShowUploadDialog = FP_GetRegKey("ShowUploadDialog", 1);
Opt.ResumeDefault = FP_GetRegKey("ResumeDefault", 0);
Opt.UpdateDescriptions = FP_GetRegKey("UpdateDescriptions", 0);
Opt.PassiveMode = FP_GetRegKey("PassiveMode", 0);
FP_GetRegKey("CharTable", Opt.Table,NULL,ARRAYSIZE(Opt.Table));
FP_GetRegKey("DescriptionNames", Opt.DescriptionNames,"00_index.txt,0index,0index.txt",ARRAYSIZE(Opt.DescriptionNames));
FP_GetRegKey("Firewall",Opt.Firewall,NULL,ARRAYSIZE(Opt.Firewall));
FP_GetRegKey("DefaultPassword", (BYTE *)str,(BYTE *)NULL,ARRAYSIZE(str));
DecryptPassword((BYTE*)str,Opt.DefaultPassword);
//JM
Opt.CmdLength = Max(5,Min(FP_ConHeight()-5,FP_GetRegKey("CmdLength",7)));
Opt.CmdLine = Max(10,Min(FP_ConWidth()-9,FP_GetRegKey("CmdLine",70)));
Opt.IOBuffSize = Max(FTR_MINBUFFSIZE,(DWORD)FP_GetRegKey("IOBuffSize",512));
Opt.dDelimit = FP_GetRegKey("DigitDelimit", TRUE);
Opt.dDelimiter = (char)FP_GetRegKey("DigitDelimiter", 0);
Opt.WaitTimeout = FP_GetRegKey("WaitTimeout", 30);
Opt.AskAbort = FP_GetRegKey("AskAbort", TRUE);
Opt.WaitIdle = FP_GetRegKey("WaitIdle", 1);
Opt.CmdLogLimit = FP_GetRegKey("CmdLogLimit", 100);
Opt.ShowIdle = FP_GetRegKey("ShowIdle", TRUE);
Opt.TimeoutRetry = FP_GetRegKey("TimeoutRetry", FALSE);
Opt.RetryCount = FP_GetRegKey("RetryCount", 0);
Opt.LogOutput = FP_GetRegKey("LogOutput", FALSE);
Opt._ShowPassword = FP_GetRegKey("ShowPassword", FALSE);
Opt.IdleColor = FP_GetRegKey("IdleColor", FAR_COLOR(fccCYAN,fccBLUE));
Opt.IdleMode = FP_GetRegKey("IdleMode", IDLE_CONSOLE);
Opt.LongBeepTimeout = FP_GetRegKey("BeepTimeout", 30);
Opt.KeepAlive = FP_GetRegKey("KeepAlive", 60);
Opt.IdleShowPeriod = FP_GetRegKey("IdleShowPeriod", 700);
Opt.IdleStartPeriod = FP_GetRegKey("IdleStartPeriod", 4000);
Opt.AskLoginFail = FP_GetRegKey("AskLoginFail", TRUE);
Opt.ExtCmdView = FP_GetRegKey("ExtCmdView", TRUE);
Opt.AutoAnonymous = FP_GetRegKey("AutoAnonymous", TRUE);
Opt.CloseDots = FP_GetRegKey("CloseDots", TRUE);
Opt.QuoteClipboardNames= FP_GetRegKey("QuoteClipboardNames",TRUE);
Opt.SetHiddenOnAbort = FP_GetRegKey("SetHiddenOnAbort", FALSE);
Opt.PwdSecurity = FP_GetRegKey("PwdSecurity", 0);
Opt.WaitCounter = FP_GetRegKey("WaitCounter", 0);
Opt.RetryTimeout = FP_GetRegKey("RetryTimeout", 10);
Opt.DoNotExpandErrors = FP_GetRegKey("DoNotExpandErrors", FALSE);
Opt.TruncateLogFile = FP_GetRegKey("TruncateLogFile", FALSE);
Opt.ServerType = FP_GetRegKey("ServerType", FTP_TYPE_DETECT);
Opt.UseBackups = FP_GetRegKey("UseBackups", TRUE);
Opt.ProcessCmd = FP_GetRegKey("ProcessCmd", TRUE);
Opt.FFDup = FP_GetRegKey("FFDup", FALSE);
Opt.UndupFF = FP_GetRegKey("UndupFF", FALSE);
Opt.ShowSilentProgress = FP_GetRegKey("ShowSilentProgress", FALSE);
FP_GetRegKey("InvalidSymbols", Opt.InvalidSymbols, "<>|?*\"", ARRAYSIZE(Opt.InvalidSymbols));
FP_GetRegKey("CorrectedSymbols", Opt.CorrectedSymbols, "()!__\'", ARRAYSIZE(Opt.CorrectedSymbols));
for(n = 0; Opt.InvalidSymbols[n] && Opt.CorrectedSymbols[n]; n++);
Opt.InvalidSymbols[n] = 0;
Opt.CorrectedSymbols[n] = 0;
Opt.PluginColumnMode = (int)FP_GetRegKey("PluginColumnMode", MAX_DWORD);
if(Opt.PluginColumnMode < 0 || Opt.PluginColumnMode >= 10)
Opt.PluginColumnMode = -1;
FP_GetRegKey("CmdLogFile", Opt.CmdLogFile,"",ARRAYSIZE(Opt.CmdLogFile));
//Queue
Opt.RestoreState = FP_GetRegKey("QueueRestoreState", TRUE);
Opt.RemoveCompleted = FP_GetRegKey("QueueRemoveCompleted", TRUE);
Opt.sli.AddPrefix = FP_GetRegKey("AddPrefix", TRUE);
Opt.sli.AddPasswordAndUser = FP_GetRegKey("AddPasswordAndUser", TRUE);
Opt.sli.Quote = FP_GetRegKey("Quote", TRUE);
Opt.sli.Size = FP_GetRegKey("Size", TRUE);
Opt.sli.RightBound = FP_GetRegKey("RightBound", 80);
Opt.sli.ListType = (sliTypes)FP_GetRegKey("ListType", sltUrlList);
//Formats
GCMD("ServerDateFormat", "%*s %04d%02d%02d%02d%02d%02d", fmtDateFormat)
//Months
static const char *Months[12]= { "Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec"
};
for(n = 0; n < 12; n++)
{
FP_GetRegKey(Months[n], str, Months[n], ARRAYSIZE(str));
while((m=strpbrk(str,"\n\r\b")) != NULL) *m = 0;
if(!str[0])
strcpy(str,Months[n]);
Log(("month %d [%s]=[%s]",n,Opt.Months[n],str));
if(Opt.Months[n])
free(Opt.Months[n]);
Opt.Months[n] = strdup(str);
}
//CMD`s
GCMD("xcmdPUT", "STOR", cmdPut)
GCMD("xcmdAPPE", "APPE", cmdAppe)
GCMD("xcmdSTOR", "STOR", cmdStor)
GCMD("xcmdSTOU", "STOU", cmdPutUniq)
GCMD("xcmdPASV", "PASV", cmdPasv)
GCMD("xcmdPORT", "PORT", cmdPort)
GCMD("xcmdMDTM", "MDTM", cmdMDTM)
GCMD("xcmdRETR", "RETR", cmdRetr)
GCMD("xcmdREST", "REST", cmdRest)
GCMD("xcmdALLO", "ALLO", cmdAllo)
GCMD("xcmdCWD", "CWD", cmdCwd)
GCMD("xcmdXCWD", "XCWD", cmdXCwd)
GCMD("xcmdDELE", "DELE", cmdDel)
GCMD("xcmdRNFR", "RNFR", cmdRen)
GCMD("xcmdRNTO", "RNTO", cmdRenTo)
GCMD("xcmdLIST", "LIST", cmdList)
GCMD("xcmdNLIST","NLIST",cmdNList)
GCMD("xcmdUSER", "USER", cmdUser)
GCMD("xcmdPASS", "PASS", cmdPass)
GCMD("xcmdACCT", "ACCT", cmdAcct)
GCMD("xcmdPWD", "PWD", cmdPwd)
GCMD("xcmdXPWD", "XPWD", cmdXPwd)
GCMD("xcmdMKD", "MKD", cmdMkd)
GCMD("xcmdXMKD", "XMKD", cmdXMkd)
GCMD("xcmdRMD", "RMD", cmdRmd)
GCMD("xcmdXRMD", "XRMD", cmdXRmd)
GCMD("xcmdSITE", "SITE", cmdSite)
GCMD("xcmdCHMOD","CHMOD",cmdChmod)
GCMD("xcmdUMASK","UMASK",cmdUmask)
GCMD("xcmdIDLE", "IDLE", cmdIdle)
GCMD("xcmdHELP", "HELP", cmdHelp)
GCMD("xcmdQUIT", "QUIT", cmdQuit)
GCMD("xcmdCDUP", "CDUP", cmdCDUp)
GCMD("xcmdXCUP", "XCUP", cmdXCDUp)
GCMD("xcmdSYST", "SYST", cmdSyst)
GCMD("xcmdSIZE", "SIZE", cmdSize)
GCMD("xcmdSTAT", "STAT", cmdStat)
//ProcessColor
val = (int)FP_Info->AdvControl(FP_Info->ModuleNumber,ACTL_GETCOLOR,(void*)COL_DIALOGBOX);
Opt.ProcessColor = FP_GetRegKey("ProcessColor",val);
//dDelimit && dDelimiter
if(Opt.dDelimit && Opt.dDelimiter == 0)
{
if(GetLocaleInfo(GetThreadLocale(),LOCALE_STHOUSAND,str,ARRAYSIZE(str)))
{
CharToOemBuff(str,str,2);
Opt.dDelimiter = str[0];
}
else
Opt.dDelimiter = '.';
}
}
