1 // SoftEther VPN Source Code - Stable Edition Repository 2 // Mayaqua Kernel 3 // 4 // SoftEther VPN Server, Client and Bridge are free software under the Apache License, Version 2.0. 5 // 6 // Copyright (c) Daiyuu Nobori. 7 // Copyright (c) SoftEther VPN Project, University of Tsukuba, Japan. 8 // Copyright (c) SoftEther Corporation. 9 // Copyright (c) all contributors on SoftEther VPN project in GitHub. 10 // 11 // All Rights Reserved. 12 // 13 // http://www.softether.org/ 14 // 15 // This stable branch is officially managed by Daiyuu Nobori, the owner of SoftEther VPN Project. 16 // Pull requests should be sent to the Developer Edition Master Repository on https://github.com/SoftEtherVPN/SoftEtherVPN 17 // 18 // License: The Apache License, Version 2.0 19 // https://www.apache.org/licenses/LICENSE-2.0 20 // 21 // DISCLAIMER 22 // ========== 23 // 24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 25 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 27 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 29 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 // SOFTWARE. 31 // 32 // THIS SOFTWARE IS DEVELOPED IN JAPAN, AND DISTRIBUTED FROM JAPAN, UNDER 33 // JAPANESE LAWS. YOU MUST AGREE IN ADVANCE TO USE, COPY, MODIFY, MERGE, PUBLISH, 34 // DISTRIBUTE, SUBLICENSE, AND/OR SELL COPIES OF THIS SOFTWARE, THAT ANY 35 // JURIDICAL DISPUTES WHICH ARE CONCERNED TO THIS SOFTWARE OR ITS CONTENTS, 36 // AGAINST US (SOFTETHER PROJECT, SOFTETHER CORPORATION, DAIYUU NOBORI OR OTHER 37 // SUPPLIERS), OR ANY JURIDICAL DISPUTES AGAINST US WHICH ARE CAUSED BY ANY KIND 38 // OF USING, COPYING, MODIFYING, MERGING, PUBLISHING, DISTRIBUTING, SUBLICENSING, 39 // AND/OR SELLING COPIES OF THIS SOFTWARE SHALL BE REGARDED AS BE CONSTRUED AND 40 // CONTROLLED BY JAPANESE LAWS, AND YOU MUST FURTHER CONSENT TO EXCLUSIVE 41 // JURISDICTION AND VENUE IN THE COURTS SITTING IN TOKYO, JAPAN. YOU MUST WAIVE 42 // ALL DEFENSES OF LACK OF PERSONAL JURISDICTION AND FORUM NON CONVENIENS. 43 // PROCESS MAY BE SERVED ON EITHER PARTY IN THE MANNER AUTHORIZED BY APPLICABLE 44 // LAW OR COURT RULE. 45 // 46 // USE ONLY IN JAPAN. DO NOT USE THIS SOFTWARE IN ANOTHER COUNTRY UNLESS YOU HAVE 47 // A CONFIRMATION THAT THIS SOFTWARE DOES NOT VIOLATE ANY CRIMINAL LAWS OR CIVIL 48 // RIGHTS IN THAT PARTICULAR COUNTRY. USING THIS SOFTWARE IN OTHER COUNTRIES IS 49 // COMPLETELY AT YOUR OWN RISK. THE SOFTETHER VPN PROJECT HAS DEVELOPED AND 50 // DISTRIBUTED THIS SOFTWARE TO COMPLY ONLY WITH THE JAPANESE LAWS AND EXISTING 51 // CIVIL RIGHTS INCLUDING PATENTS WHICH ARE SUBJECTS APPLY IN JAPAN. OTHER 52 // COUNTRIES' LAWS OR CIVIL RIGHTS ARE NONE OF OUR CONCERNS NOR RESPONSIBILITIES. 53 // WE HAVE NEVER INVESTIGATED ANY CRIMINAL REGULATIONS, CIVIL LAWS OR 54 // INTELLECTUAL PROPERTY RIGHTS INCLUDING PATENTS IN ANY OF OTHER 200+ COUNTRIES 55 // AND TERRITORIES. BY NATURE, THERE ARE 200+ REGIONS IN THE WORLD, WITH 56 // DIFFERENT LAWS. IT IS IMPOSSIBLE TO VERIFY EVERY COUNTRIES' LAWS, REGULATIONS 57 // AND CIVIL RIGHTS TO MAKE THE SOFTWARE COMPLY WITH ALL COUNTRIES' LAWS BY THE 58 // PROJECT. EVEN IF YOU WILL BE SUED BY A PRIVATE ENTITY OR BE DAMAGED BY A 59 // PUBLIC SERVANT IN YOUR COUNTRY, THE DEVELOPERS OF THIS SOFTWARE WILL NEVER BE 60 // LIABLE TO RECOVER OR COMPENSATE SUCH DAMAGES, CRIMINAL OR CIVIL 61 // RESPONSIBILITIES. NOTE THAT THIS LINE IS NOT LICENSE RESTRICTION BUT JUST A 62 // STATEMENT FOR WARNING AND DISCLAIMER. 63 // 64 // READ AND UNDERSTAND THE 'WARNING.TXT' FILE BEFORE USING THIS SOFTWARE. 65 // SOME SOFTWARE PROGRAMS FROM THIRD PARTIES ARE INCLUDED ON THIS SOFTWARE WITH 66 // LICENSE CONDITIONS WHICH ARE DESCRIBED ON THE 'THIRD_PARTY.TXT' FILE. 67 // 68 // 69 // SOURCE CODE CONTRIBUTION 70 // ------------------------ 71 // 72 // Your contribution to SoftEther VPN Project is much appreciated. 73 // Please send patches to us through GitHub. 74 // Read the SoftEther VPN Patch Acceptance Policy in advance: 75 // http://www.softether.org/5-download/src/9.patch 76 // 77 // 78 // DEAR SECURITY EXPERTS 79 // --------------------- 80 // 81 // If you find a bug or a security vulnerability please kindly inform us 82 // about the problem immediately so that we can fix the security problem 83 // to protect a lot of users around the world as soon as possible. 84 // 85 // Our e-mail address for security reports is: 86 // softether-vpn-security [at] softether.org 87 // 88 // Please note that the above e-mail address is not a technical support 89 // inquiry address. If you need technical assistance, please visit 90 // http://www.softether.org/ and ask your question on the users forum. 91 // 92 // Thank you for your cooperation. 93 // 94 // 95 // NO MEMORY OR RESOURCE LEAKS 96 // --------------------------- 97 // 98 // The memory-leaks and resource-leaks verification under the stress 99 // test has been passed before release this source code. 100 101 102 // FileIO.h 103 // Header of FileIO.c 104 105 #ifndef FILEIO_H 106 #define FILEIO_H 107 108 // Constant 109 #define HAMCORE_DIR_NAME "hamcore" 110 #define HAMCORE_FILE_NAME "hamcore.se2" 111 #define HAMCORE_FILE_NAME_2 "_hamcore.se2" 112 #define HAMCORE_TEXT_NAME "hamcore.txt" 113 #define HAMCORE_HEADER_DATA "HamCore" 114 #define HAMCORE_HEADER_SIZE 7 115 #define HAMCORE_CACHE_EXPIRES (5 * 60 * 1000) 116 117 // IO structure 118 struct IO 119 { 120 char Name[MAX_SIZE]; 121 wchar_t NameW[MAX_SIZE]; 122 void *pData; 123 bool WriteMode; 124 bool HamMode; 125 BUF *HamBuf; 126 UINT64 SetUpdateTime, SetCreateTime; 127 UINT64 GetUpdateTime, GetCreateTime, GetAccessTime; 128 }; 129 130 // HC structure 131 typedef struct HC 132 { 133 char *FileName; // File name 134 UINT Size; // File size 135 UINT SizeCompressed; // Compressed file size 136 UINT Offset; // Offset 137 void *Buffer; // Buffer 138 UINT64 LastAccess; // Access Date 139 } HC; 140 141 // DIRENT structure 142 struct DIRENT 143 { 144 bool Folder; // Folder 145 char *FileName; // File name (ANSI) 146 wchar_t *FileNameW; // File name (Unicode) 147 UINT64 FileSize; // File size 148 UINT64 CreateDate; // Creation Date 149 UINT64 UpdateDate; // Updating date 150 }; 151 152 // DIRLIST structure 153 struct DIRLIST 154 { 155 UINT NumFiles; // Number of files 156 struct DIRENT **File; // File array 157 }; 158 159 // ZIP related structure 160 #ifdef OS_WIN32 161 #pragma pack(push, 1) 162 #endif // OS_WIN32 163 164 struct ZIP_DATA_HEADER 165 { 166 UINT Signature; 167 USHORT NeedVer; 168 USHORT Option; 169 USHORT CompType; 170 USHORT FileTime; 171 USHORT FileDate; 172 UINT Crc32; 173 UINT CompSize; 174 UINT UncompSize; 175 USHORT FileNameLen; 176 USHORT ExtraLen; 177 } GCC_PACKED; 178 179 struct ZIP_DATA_FOOTER 180 { 181 UINT Signature; 182 UINT Crc32; 183 UINT CompSize; 184 UINT UncompSize; 185 } GCC_PACKED; 186 187 struct ZIP_DIR_HEADER 188 { 189 UINT Signature; 190 USHORT MadeVer; 191 USHORT NeedVer; 192 USHORT Option; 193 USHORT CompType; 194 USHORT FileTime; 195 USHORT FileDate; 196 UINT Crc32; 197 UINT CompSize; 198 UINT UncompSize; 199 USHORT FileNameLen; 200 USHORT ExtraLen; 201 USHORT CommentLen; 202 USHORT DiskNum; 203 USHORT InAttr; 204 UINT OutAttr; 205 UINT HeaderPos; 206 } GCC_PACKED; 207 208 struct ZIP_END_HEADER 209 { 210 UINT Signature; 211 USHORT DiskNum; 212 USHORT StartDiskNum; 213 USHORT DiskDirEntry; 214 USHORT DirEntry; 215 UINT DirSize; 216 UINT StartPos; 217 USHORT CommentLen; 218 } GCC_PACKED; 219 220 #define ZIP_SIGNATURE 0x04034B50 221 #define ZIP_SIGNATURE_END 0x06054B50 222 #define ZIP_VERSION 10 223 #define ZIP_VERSION_WITH_COMPRESS 20 224 225 #ifdef OS_WIN32 226 #pragma pack(pop) 227 #endif // OS_WIN32 228 229 struct ZIP_FILE 230 { 231 char Name[MAX_PATH]; 232 UINT Size; 233 UINT64 DateTime; 234 UINT Attributes; 235 UINT CurrentSize; 236 UINT CompressSize; 237 UINT Crc32; 238 UINT HeaderPos; 239 }; 240 241 struct ZIP_PACKER 242 { 243 FIFO *Fifo; 244 LIST *FileList; 245 ZIP_FILE *CurrentFile; 246 }; 247 248 struct ENUM_DIR_WITH_SUB_DATA 249 { 250 LIST *FileList; 251 }; 252 253 void InitCrc32(); 254 UINT Crc32(void *buf, UINT pos, UINT len); 255 UINT Crc32First(void *buf, UINT pos, UINT len); 256 UINT Crc32Next(void *buf, UINT pos, UINT len, UINT last_crc32); 257 UINT Crc32Finish(UINT last_crc32); 258 void WriteZipDataHeader(ZIP_FILE *f, ZIP_DATA_HEADER *h, bool write_sizes); 259 void WriteZipDataFooter(ZIP_FILE *f, ZIP_DATA_FOOTER *h); 260 ZIP_PACKER *NewZipPacker(); 261 void FreeZipPacker(ZIP_PACKER *p); 262 void ZipAddFileSimple(ZIP_PACKER *p, char *name, UINT64 dt, UINT attribute, void *data, UINT size); 263 bool ZipAddRealFileW(ZIP_PACKER *p, char *name, UINT64 dt, UINT attribute, wchar_t *srcname); 264 bool ZipAddRealFile(ZIP_PACKER *p, char *name, UINT64 dt, UINT attribute, char *srcname); 265 void ZipAddFileStart(ZIP_PACKER *p, char *name, UINT size, UINT64 dt, UINT attribute); 266 UINT ZipAddFileData(ZIP_PACKER *p, void *data, UINT pos, UINT len); 267 void ZipAddFileFooter(ZIP_PACKER *p); 268 FIFO *ZipFinish(ZIP_PACKER *p); 269 bool ZipWriteW(ZIP_PACKER *p, wchar_t *name); 270 271 bool DeleteDirInner(char *name); 272 bool DeleteDirInnerW(wchar_t *name); 273 bool DeleteDir(char *name); 274 bool DeleteDirW(wchar_t *name); 275 bool MakeDirInner(char *name); 276 bool MakeDirInnerW(wchar_t *name); 277 bool MakeDir(char *name); 278 bool MakeDirW(wchar_t *name); 279 bool MakeDirEx(char *name); 280 bool MakeDirExW(wchar_t *name); 281 bool FileDeleteInner(char *name); 282 bool FileDeleteInnerW(wchar_t *name); 283 bool FileDelete(char *name); 284 bool FileDeleteW(wchar_t *name); 285 bool FileSeek(IO *o, UINT mode, int offset); 286 UINT FileSize(IO *o); 287 UINT64 FileSize64(IO *o); 288 UINT FileSizeEx(char *name); 289 UINT FileSizeExW(wchar_t *name); 290 bool FileRead(IO *o, void *buf, UINT size); 291 bool FileWrite(IO *o, void *buf, UINT size); 292 void FileFlush(IO *o); 293 void FileClose(IO *o); 294 void FileCloseEx(IO *o, bool no_flush); 295 void FileCloseAndDelete(IO *o); 296 IO *FileCreateInner(char *name); 297 IO *FileCreateInnerW(wchar_t *name); 298 IO *FileCreate(char *name); 299 IO *FileCreateW(wchar_t *name); 300 bool FileWriteAll(char *name, void *data, UINT size); 301 bool FileWriteAllW(wchar_t *name, void *data, UINT size); 302 IO *FileOpenInner(char *name, bool write_mode, bool read_lock); 303 IO *FileOpenInnerW(wchar_t *name, bool write_mode, bool read_lock); 304 IO *FileOpen(char *name, bool write_mode); 305 IO *FileOpenW(wchar_t *name, bool write_mode); 306 IO *FileOpenEx(char *name, bool write_mode, bool read_lock); 307 IO *FileOpenExW(wchar_t *name, bool write_mode, bool read_lock); 308 void ConvertPath(char *path); 309 void ConvertPathW(wchar_t *path); 310 bool FileRenameInner(char *old_name, char *new_name); 311 bool FileRenameInnerW(wchar_t *old_name, wchar_t *new_name); 312 bool FileRename(char *old_name, char *new_name); 313 bool FileRenameW(wchar_t *old_name, wchar_t *new_name); 314 void NormalizePath(char *dst, UINT size, char *src); 315 void NormalizePathW(wchar_t *dst, UINT size, wchar_t *src); 316 bool GetRelativePathW(wchar_t *dst, UINT size, wchar_t *fullpath, wchar_t *basepath); 317 bool GetRelativePath(char *dst, UINT size, char *fullpath, char *basepath); 318 TOKEN_LIST *ParseSplitedPath(char *path); 319 UNI_TOKEN_LIST *ParseSplitedPathW(wchar_t *path); 320 char *GetCurrentPathEnvStr(); 321 bool IsFileExistsInner(char *name); 322 bool IsFileExistsInnerW(wchar_t *name); 323 bool IsFileExists(char *name); 324 bool IsFileExistsW(wchar_t *name); 325 void InnerFilePath(char *dst, UINT size, char *src); 326 void InnerFilePathW(wchar_t *dst, UINT size, wchar_t *src); 327 void ConbinePath(char *dst, UINT size, char *dirname, char *filename); 328 void ConbinePathW(wchar_t *dst, UINT size, wchar_t *dirname, wchar_t *filename); 329 void CombinePath(char *dst, UINT size, char *dirname, char *filename); 330 void CombinePathW(wchar_t *dst, UINT size, wchar_t *dirname, wchar_t *filename); 331 void GetDirNameFromFilePath(char *dst, UINT size, char *filepath); 332 void GetDirNameFromFilePathW(wchar_t *dst, UINT size, wchar_t *filepath); 333 void GetFileNameFromFilePath(char *dst, UINT size, char *filepath); 334 void GetFileNameFromFilePathW(wchar_t *dst, UINT size, wchar_t *filepath); 335 void MakeSafeFileName(char *dst, UINT size, char *src); 336 void MakeSafeFileNameW(wchar_t *dst, UINT size, wchar_t *src); 337 void InitGetExeName(char *arg); 338 void UnixGetExeNameW(wchar_t *name, UINT size, wchar_t *arg); 339 void GetExeName(char *name, UINT size); 340 void GetExeNameW(wchar_t *name, UINT size); 341 void GetExeDir(char *name, UINT size); 342 void GetExeDirW(wchar_t *name, UINT size); 343 void GetLogDir(char *name, UINT size); 344 void GetLogDirW(wchar_t *name, UINT size); 345 void GetDbDir(char *name, UINT size); 346 void GetDbDirW(wchar_t *name, UINT size); 347 void GetPidDir(char *name, UINT size); 348 void GetPidDirW(wchar_t *name, UINT size); 349 void BuildHamcore(char *dst_filename, char *src_dir, bool unix_only); 350 int CompareHamcore(void *p1, void *p2); 351 void InitHamcore(); 352 void FreeHamcore(); 353 BUF *ReadHamcore(char *name); 354 BUF *ReadHamcoreW(wchar_t *filename); 355 void SafeFileName(char *name); 356 void SafeFileNameW(wchar_t *name); 357 void UniSafeFileName(wchar_t *name); 358 DIRLIST *EnumDir(char *dirname); 359 DIRLIST *EnumDirW(wchar_t *dirname); 360 DIRLIST *EnumDirEx(char *dirname, COMPARE *compare); 361 DIRLIST *EnumDirExW(wchar_t *dirname, COMPARE *compare); 362 UNI_TOKEN_LIST *EnumDirWithSubDirsW(wchar_t *dirname); 363 TOKEN_LIST *EnumDirWithSubDirs(char *dirname); 364 void EnumDirWithSubDirsMain(ENUM_DIR_WITH_SUB_DATA *d, wchar_t *dirname); 365 void FreeDir(DIRLIST *d); 366 int CompareDirListByName(void *p1, void *p2); 367 bool GetDiskFree(char *path, UINT64 *free_size, UINT64 *used_size, UINT64 *total_size); 368 bool GetDiskFreeW(wchar_t *path, UINT64 *free_size, UINT64 *used_size, UINT64 *total_size); 369 void ConvertSafeFileName(char *dst, UINT size, char *src); 370 void ConvertSafeFileNameW(wchar_t *dst, UINT size, wchar_t *src); 371 bool FileReplaceRename(char *old_name, char *new_name); 372 bool FileReplaceRenameW(wchar_t *old_name, wchar_t *new_name); 373 bool IsFile(char *name); 374 bool IsFileW(wchar_t *name); 375 void GetCurrentDirW(wchar_t *name, UINT size); 376 void GetCurrentDir(char *name, UINT size); 377 bool SaveFileW(wchar_t *name, void *data, UINT size); 378 bool SaveFile(char *name, void *data, UINT size); 379 bool IsFileWriteLockedW(wchar_t *name); 380 bool IsFileWriteLocked(char *name); 381 bool IsInLines(BUF *buf, char *str, bool instr); 382 bool IsInLinesFile(wchar_t *filename, char *str, bool instr); 383 384 #endif // FILEIO_H 385 386 387 388