AMajor/SoftEtherVPN
1
0
Fork 0
mirror of https://github.com/SoftEtherVPN/SoftEtherVPN.git synced 2024-12-26 10:09:52 +03:00
Code Releases Activity

Hamcore: Remove unused functions

Browse Source
This commit is contained in:
Davide Beatrici 2021-02-26 04:32:15 +01:00
parent 1301dc93c6
commit cf2585c079
5 changed files with 0 additions and 342 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

320
src/Mayaqua/FileIO.c
View File

@ -610,110 +610,6 @@ bool GetDiskFree(char *path, UINT64 *free_size, UINT64 *used_size, UINT64 *total
return ret;
}
// Enumeration of direction with all sub directories
TOKEN_LIST *EnumDirWithSubDirs(char *dirname)
{
TOKEN_LIST *ret;
UNI_TOKEN_LIST *ret2;
wchar_t tmp[MAX_SIZE];
// Validate arguments
if (dirname == NULL)
{
dirname = "./";
}
StrToUni(tmp, sizeof(tmp), dirname);
ret2 = EnumDirWithSubDirsW(tmp);
ret = UniTokenListToTokenList(ret2);
UniFreeToken(ret2);
return ret;
}
UNI_TOKEN_LIST *EnumDirWithSubDirsW(wchar_t *dirname)
{
ENUM_DIR_WITH_SUB_DATA d;
UNI_TOKEN_LIST *ret;
UINT i;
// Validate arguments
if (dirname == NULL)
{
dirname = L"./";
}
Zero(&d, sizeof(d));
d.FileList = NewListFast(NULL);
EnumDirWithSubDirsMain(&d, dirname);
ret = ZeroMalloc(sizeof(UNI_TOKEN_LIST));
ret->NumTokens = LIST_NUM(d.FileList);
ret->Token = ZeroMalloc(sizeof(wchar_t *) * ret->NumTokens);
for (i = 0;i < ret->NumTokens;i++)
{
wchar_t *s = LIST_DATA(d.FileList, i);
ret->Token[i] = UniCopyStr(s);
}
FreeStrList(d.FileList);
return ret;
}
void EnumDirWithSubDirsMain(ENUM_DIR_WITH_SUB_DATA *d, wchar_t *dirname)
{
DIRLIST *dir;
UINT i;
// Validate arguments
if (d == NULL || dirname == NULL)
{
return;
}
dir = EnumDirExW(dirname, NULL);
if (dir == NULL)
{
return;
}
// Files
for (i = 0;i < dir->NumFiles;i++)
{
DIRENT *e = dir->File[i];
if (e->Folder == false)
{
wchar_t tmp[MAX_SIZE];
ConbinePathW(tmp, sizeof(tmp), dirname, e->FileNameW);
Add(d->FileList, CopyUniStr(tmp));
}
}
// Sub directories
for (i = 0;i < dir->NumFiles;i++)
{
DIRENT *e = dir->File[i];
if (e->Folder)
{
wchar_t tmp[MAX_SIZE];
ConbinePathW(tmp, sizeof(tmp), dirname, e->FileNameW);
EnumDirWithSubDirsMain(d, tmp);
}
}
FreeDir(dir);
}
// Enumeration of directory
DIRLIST *EnumDirEx(char *dirname, COMPARE *compare)
{
@ -1079,161 +975,6 @@ void FreeHamcore()
hamcore = NULL;
}
// Build a Hamcore file
void BuildHamcore(char *dst_filename, char *src_dir, bool unix_only)
{
char exe_dir[MAX_SIZE];
bool ok = true;
LIST *o;
UINT i;
TOKEN_LIST *src_file_list;
GetExeDir(exe_dir, sizeof(exe_dir));
src_file_list = EnumDirWithSubDirs(src_dir);
o = NewListFast(CompareHamcore);
for (i = 0;i < src_file_list->NumTokens;i++)
{
char rpath[MAX_SIZE];
BUF *b;
char s[MAX_SIZE];
StrCpy(s, sizeof(s), src_file_list->Token[i]);
Trim(s);
if (GetRelativePath(rpath, sizeof(rpath), s, src_dir) == false)
{
// Unknown error !
}
else
{
bool ok = true;
ReplaceStr(rpath, sizeof(rpath), rpath, "/", "\\");
if (unix_only)
{
// Exclude non-UNIX files
if (EndWith(s, ".exe") ||
EndWith(s, ".dll") ||
EndWith(s, ".sys") ||
EndWith(s, ".inf") ||
EndWith(s, ".cat") ||
EndWith(s, ".wav"))
{
ok = false;
}
}
if (InStr(rpath, "\\node_modules\\"))
{
// Exclude node_modules in the hamcore\webroot
ok = false;
}
if (ok)
{
b = ReadDump(s);
if (b == NULL)
{
Print("Failed to open '%s'.\n", s);
ok = false;
}
else
{
HC *c = ZeroMalloc(sizeof(HC));
UINT tmp_size;
void *tmp;
c->FileName = CopyStr(rpath);
c->Size = b->Size;
tmp_size = CalcCompress(c->Size);
tmp = Malloc(tmp_size);
c->SizeCompressed = Compress(tmp, tmp_size, b->Buf, b->Size);
c->Buffer = tmp;
Insert(o, c);
Print("%s: %u -> %u\n", s, c->Size, c->SizeCompressed);
FreeBuf(b);
}
}
}
}
if (ok)
{
// Calculate the offset of the buffer for each file
UINT i, z;
char tmp[MAX_SIZE];
BUF *b;
z = 0;
z += HAMCORE_HEADER_SIZE;
// The number of files
z += sizeof(UINT);
// For file table first
for (i = 0;i < LIST_NUM(o);i++)
{
HC *c = LIST_DATA(o, i);
// File name
z += StrLen(c->FileName) + sizeof(UINT);
// File size
z += sizeof(UINT);
z += sizeof(UINT);
// Offset data
z += sizeof(UINT);
}
// File body
for (i = 0;i < LIST_NUM(o);i++)
{
HC *c = LIST_DATA(o, i);
// Buffer body
c->Offset = z;
printf("%s: offset: %u\n", c->FileName, c->Offset);
z += c->SizeCompressed;
}
// Writing
b = NewBuf();
// Header
WriteBuf(b, HAMCORE_HEADER_DATA, HAMCORE_HEADER_SIZE);
WriteBufInt(b, LIST_NUM(o));
for (i = 0;i < LIST_NUM(o);i++)
{
HC *c = LIST_DATA(o, i);
// File name
WriteBufStr(b, c->FileName);
// File size
WriteBufInt(b, c->Size);
WriteBufInt(b, c->SizeCompressed);
// Offset
WriteBufInt(b, c->Offset);
}
// Body
for (i = 0;i < LIST_NUM(o);i++)
{
HC *c = LIST_DATA(o, i);
WriteBuf(b, c->Buffer, c->SizeCompressed);
}
// Writing
StrCpy(tmp, sizeof(tmp), dst_filename);
Print("Writing %s...\n", tmp);
FileDelete(tmp);
DumpBuf(b, tmp);
FreeBuf(b);
}
for (i = 0;i < LIST_NUM(o);i++)
{
HC *c = LIST_DATA(o, i);
Free(c->Buffer);
Free(c->FileName);
Free(c);
}
ReleaseList(o);
FreeToken(src_file_list);
}
// Comparison of the HCs
int CompareHamcore(void *p1, void *p2)
{
@ -1798,67 +1539,6 @@ UNI_TOKEN_LIST *ParseSplitedPathW(wchar_t *path)
return ret;
}
// Get the relative path
bool GetRelativePathW(wchar_t *dst, UINT size, wchar_t *fullpath, wchar_t *basepath)
{
wchar_t fullpath2[MAX_SIZE];
wchar_t basepath2[MAX_SIZE];
// Validate arguments
if (dst == NULL || fullpath == NULL || basepath == NULL)
{
return false;
}
ClearUniStr(dst, size);
NormalizePathW(fullpath2, sizeof(fullpath2), fullpath);
NormalizePathW(basepath2, sizeof(basepath2), basepath);
#ifdef OS_WIN32
UniStrCat(basepath2, sizeof(basepath2), L"\\");
#else // OS_WIN32
UniStrCat(basepath2, sizeof(basepath2), L"/");
#endif // OS_WIN32
if (UniStrLen(fullpath2) <= UniStrLen(basepath2))
{
return false;
}
if (UniStartWith(fullpath2, basepath2) == false)
{
return false;
}
UniStrCpy(dst, size, fullpath2 + UniStrLen(basepath2));
return true;
}
bool GetRelativePath(char *dst, UINT size, char *fullpath, char *basepath)
{
wchar_t dst_w[MAX_SIZE];
wchar_t fullpath_w[MAX_SIZE];
wchar_t basepath_w[MAX_SIZE];
bool ret;
// Validate arguments
if (dst == NULL || fullpath == NULL || basepath == NULL)
{
return false;
}
StrToUni(fullpath_w, sizeof(fullpath_w), fullpath);
StrToUni(basepath_w, sizeof(basepath_w), basepath);
ret = GetRelativePathW(dst_w, sizeof(dst_w), fullpath_w, basepath_w);
if (ret == false)
{
return false;
}
UniToStr(dst, size, dst_w);
return true;
}
// Normalize the file path
void NormalizePathW(wchar_t *dst, UINT size, wchar_t *src)
{

14
src/Mayaqua/FileIO.h
View File

@ -146,11 +146,6 @@ struct ZIP_PACKER
ZIP_FILE *CurrentFile;
};
struct ENUM_DIR_WITH_SUB_DATA
{
LIST *FileList;
};
void InitCrc32();
UINT Crc32(void *buf, UINT pos, UINT len);
UINT Crc32First(void *buf, UINT pos, UINT len);
@ -202,8 +197,6 @@ bool FileRenameInnerW(wchar_t *old_name, wchar_t *new_name);
bool FileRenameW(wchar_t *old_name, wchar_t *new_name);
void NormalizePath(char *dst, UINT size, char *src);
void NormalizePathW(wchar_t *dst, UINT size, wchar_t *src);
bool GetRelativePathW(wchar_t *dst, UINT size, wchar_t *fullpath, wchar_t *basepath);
bool GetRelativePath(char *dst, UINT size, char *fullpath, char *basepath);
UNI_TOKEN_LIST *ParseSplitedPathW(wchar_t *path);
char *GetCurrentPathEnvStr();
bool IsFileExistsInnerW(wchar_t *name);
@ -232,7 +225,6 @@ void GetDbDir(char *name, UINT size);
void GetDbDirW(wchar_t *name, UINT size);
void GetPidDir(char *name, UINT size);
void GetPidDirW(wchar_t *name, UINT size);
void BuildHamcore(char *dst_filename, char *src_dir, bool unix_only);
int CompareHamcore(void *p1, void *p2);
void InitHamcore();
void FreeHamcore();
@ -244,9 +236,6 @@ DIRLIST *EnumDir(char *dirname);
DIRLIST *EnumDirW(wchar_t *dirname);
DIRLIST *EnumDirEx(char *dirname, COMPARE *compare);
DIRLIST *EnumDirExW(wchar_t *dirname, COMPARE *compare);
UNI_TOKEN_LIST *EnumDirWithSubDirsW(wchar_t *dirname);
TOKEN_LIST *EnumDirWithSubDirs(char *dirname);
void EnumDirWithSubDirsMain(ENUM_DIR_WITH_SUB_DATA *d, wchar_t *dirname);
void FreeDir(DIRLIST *d);
int CompareDirListByName(void *p1, void *p2);
bool GetDiskFree(char *path, UINT64 *free_size, UINT64 *used_size, UINT64 *total_size);
@ -261,6 +250,3 @@ bool IsInLines(BUF *buf, char *str, bool instr);
bool IsInLinesFile(wchar_t *filename, char *str, bool instr);
#endif // FILEIO_H

6
src/Mayaqua/Internat.c
View File

@ -22,12 +22,6 @@ static LOCK *iconv_lock = NULL;
void *iconv_cache_wide_to_str = 0;
void *iconv_cache_str_to_wide = 0;
// Initialize the string
void ClearUniStr(wchar_t *str, UINT str_size)
{
UniStrCpy(str, str_size, L"");
}
// Examine whether the string contains the specified character
bool UniInChar(wchar_t *string, wchar_t c)
{

1
src/Mayaqua/Internat.h
View File

@ -98,7 +98,6 @@ bool UniIsSafeChar(wchar_t c);
BUF *UniStrToBin(wchar_t *str);
bool UniInStr(wchar_t *str, wchar_t *keyword);
bool UniInStrEx(wchar_t *str, wchar_t *keyword, bool case_sensitive);
void ClearUniStr(wchar_t *str, UINT str_size);
bool UniInChar(wchar_t *string, wchar_t c);
UNI_TOKEN_LIST *UniGetLines(wchar_t *str);
wchar_t *UniDefaultTokenSplitChars();

1
src/Mayaqua/MayaType.h
View File

@ -444,7 +444,6 @@ typedef struct ZIP_DIR_HEADER ZIP_DIR_HEADER;
typedef struct ZIP_END_HEADER ZIP_END_HEADER;
typedef struct ZIP_FILE ZIP_FILE;
typedef struct ZIP_PACKER ZIP_PACKER;
typedef struct ENUM_DIR_WITH_SUB_DATA ENUM_DIR_WITH_SUB_DATA;
// TcpIp.h
typedef struct MAC_HEADER MAC_HEADER;