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 // Memory.h 103 // Header of Memory.c 104 105 #ifndef MEMORY_H 106 #define MEMORY_H 107 108 // MallocFast (not implemented) 109 #define MallocFast Malloc 110 #define ZeroMallocFast ZeroMalloc 111 112 // Memory size that can be passed to the kernel at a time 113 #define MAX_SEND_BUF_MEM_SIZE (10 * 1024 * 1024) 114 115 // The magic number for memory tag 116 #define MEMTAG_MAGIC 0x49414449 117 118 #define CALC_MALLOCSIZE(size) ((MAX(size, 1)) + sizeof(MEMTAG)) 119 #define MEMTAG_TO_POINTER(p) ((void *)(((UCHAR *)(p)) + sizeof(MEMTAG))) 120 #define POINTER_TO_MEMTAG(p) ((MEMTAG *)(((UCHAR *)(p)) - sizeof(MEMTAG))) 121 #define IS_NULL_POINTER(p) (((p) == NULL) || ((POINTER_TO_UINT64(p) == (UINT64)sizeof(MEMTAG)))) 122 123 // Fixed size of a block of memory pool 124 #define MEMPOOL_MAX_SIZE 3000 125 126 127 // Memory tag 128 struct MEMTAG 129 { 130 UINT Magic; 131 UINT Size; 132 bool ZeroFree; 133 UINT Padding; 134 }; 135 136 // Buffer 137 struct BUF 138 { 139 void *Buf; 140 UINT Size; 141 UINT SizeReserved; 142 UINT Current; 143 }; 144 145 // FIFO 146 struct FIFO 147 { 148 REF *ref; 149 LOCK *lock; 150 void *p; 151 UINT pos, size, memsize; 152 UINT64 total_read_size; 153 UINT64 total_write_size; 154 bool fixed; 155 }; 156 157 // List 158 struct LIST 159 { 160 REF *ref; 161 UINT num_item, num_reserved; 162 void **p; 163 LOCK *lock; 164 COMPARE *cmp; 165 bool sorted; 166 UINT64 Param1; 167 }; 168 169 // Queue 170 struct QUEUE 171 { 172 REF *ref; 173 UINT num_item; 174 FIFO *fifo; 175 LOCK *lock; 176 }; 177 178 // Stack 179 struct SK 180 { 181 REF *ref; 182 UINT num_item, num_reserved; 183 void **p; 184 LOCK *lock; 185 bool no_compact; 186 }; 187 188 // Candidate list 189 struct CANDIDATE 190 { 191 wchar_t *Str; // String 192 UINT64 LastSelectedTime; // Date and time last selected 193 }; 194 195 struct STRMAP_ENTRY 196 { 197 char *Name; 198 void *Value; 199 }; 200 201 // Shared buffer 202 struct SHARED_BUFFER 203 { 204 REF *Ref; 205 void *Data; 206 UINT Size; 207 }; 208 209 // Macro 210 #define LIST_DATA(o, i) (((o) != NULL) ? ((o)->p[(i)]) : NULL) 211 #define LIST_NUM(o) (((o) != NULL) ? (o)->num_item : 0) 212 #define HASH_LIST_NUM(o) (((o) != NULL) ? (o)->NumItems : 0) 213 214 // Function pointer type to get a hash function 215 typedef UINT (GET_HASH)(void *p); 216 217 // Hash list 218 struct HASH_LIST 219 { 220 UINT Bits; 221 UINT Size; 222 GET_HASH *GetHashProc; 223 COMPARE *CompareProc; 224 LOCK *Lock; 225 REF *Ref; 226 LIST **Entries; 227 UINT NumItems; 228 LIST *AllList; 229 }; 230 231 // PRAND 232 struct PRAND 233 { 234 UCHAR Key[20]; 235 CRYPT *Rc4; 236 }; 237 238 // Function prototype 239 HASH_LIST *NewHashList(GET_HASH *get_hash_proc, COMPARE *compare_proc, UINT bits, bool make_list); 240 void ReleaseHashList(HASH_LIST *h); 241 void CleanupHashList(HASH_LIST *h); 242 void AddHash(HASH_LIST *h, void *p); 243 bool DeleteHash(HASH_LIST *h, void *p); 244 void *SearchHash(HASH_LIST *h, void *t); 245 UINT CalcHashForHashList(HASH_LIST *h, void *p); 246 void **HashListToArray(HASH_LIST *h, UINT *num); 247 void LockHashList(HASH_LIST *h); 248 void UnlockHashList(HASH_LIST *h); 249 bool IsInHashListKey(HASH_LIST *h, UINT key); 250 void *HashListKeyToPointer(HASH_LIST *h, UINT key); 251 252 PRAND *NewPRand(void *key, UINT key_size); 253 void FreePRand(PRAND *r); 254 void PRand(PRAND *p, void *data, UINT size); 255 UINT PRandInt(PRAND *p); 256 257 LIST *NewCandidateList(); 258 void FreeCandidateList(LIST *o); 259 int ComapreCandidate(void *p1, void *p2); 260 void AddCandidate(LIST *o, wchar_t *str, UINT num_max); 261 BUF *CandidateToBuf(LIST *o); 262 LIST *BufToCandidate(BUF *b); 263 264 void *Malloc(UINT size); 265 void *MallocEx(UINT size, bool zero_clear_when_free); 266 void *ZeroMalloc(UINT size); 267 void *ZeroMallocEx(UINT size, bool zero_clear_when_free); 268 void *ReAlloc(void *addr, UINT size); 269 void Free(void *addr); 270 void CheckMemTag(MEMTAG *tag); 271 UINT GetMemSize(void *addr); 272 273 void *InternalMalloc(UINT size); 274 void *InternalReAlloc(void *addr, UINT size); 275 void InternalFree(void *addr); 276 277 void Copy(void *dst, void *src, UINT size); 278 void Move(void *dst, void *src, UINT size); 279 int Cmp(void *p1, void *p2, UINT size); 280 int CmpCaseIgnore(void *p1, void *p2, UINT size); 281 void ZeroMem(void *addr, UINT size); 282 void Zero(void *addr, UINT size); 283 void *Clone(void *addr, UINT size); 284 void *CloneTail(void *src, UINT src_size, UINT dst_size); 285 void *AddHead(void *src, UINT src_size, void *head, UINT head_size); 286 287 char B64_CodeToChar(BYTE c); 288 char B64_CharToCode(char c); 289 int B64_Encode(char *set, char *source, int len); 290 int B64_Decode(char *set, char *source, int len); 291 UINT Encode64(char *dst, char *src); 292 UINT Decode64(char *dst, char *src); 293 294 void Swap(void *buf, UINT size); 295 USHORT Swap16(USHORT value); 296 UINT Swap32(UINT value); 297 UINT64 Swap64(UINT64 value); 298 USHORT Endian16(USHORT src); 299 UINT Endian32(UINT src); 300 UINT64 Endian64(UINT64 src); 301 void EndianUnicode(wchar_t *str); 302 303 BUF *NewBuf(); 304 BUF *NewBufFromMemory(void *buf, UINT size); 305 void ClearBuf(BUF *b); 306 void WriteBuf(BUF *b, void *buf, UINT size); 307 void WriteBufBuf(BUF *b, BUF *bb); 308 void WriteBufBufWithOffset(BUF *b, BUF *bb); 309 UINT ReadBuf(BUF *b, void *buf, UINT size); 310 bool BufSkipUtf8Bom(BUF *b); 311 BUF *ReadBufFromBuf(BUF *b, UINT size); 312 void AdjustBufSize(BUF *b, UINT new_size); 313 void SeekBuf(BUF *b, UINT offset, int mode); 314 void SeekBufToEnd(BUF *b); 315 void SeekBufToBegin(BUF *b); 316 void FreeBuf(BUF *b); 317 bool BufToFile(IO *o, BUF *b); 318 BUF *FileToBuf(IO *o); 319 UINT ReadBufInt(BUF *b); 320 USHORT ReadBufShort(BUF *b); 321 UINT64 ReadBufInt64(BUF *b); 322 UCHAR ReadBufChar(BUF *b); 323 bool WriteBufInt(BUF *b, UINT value); 324 bool WriteBufInt64(BUF *b, UINT64 value); 325 bool WriteBufChar(BUF *b, UCHAR uc); 326 bool WriteBufShort(BUF *b, USHORT value); 327 bool ReadBufStr(BUF *b, char *str, UINT size); 328 bool WriteBufStr(BUF *b, char *str); 329 void WriteBufLine(BUF *b, char *str); 330 void AddBufStr(BUF *b, char *str); 331 bool DumpBuf(BUF *b, char *filename); 332 bool DumpBufW(BUF *b, wchar_t *filename); 333 bool DumpBufWIfNecessary(BUF *b, wchar_t *filename); 334 bool DumpData(void *data, UINT size, char *filename); 335 bool DumpDataW(void *data, UINT size, wchar_t *filename); 336 BUF *ReadDump(char *filename); 337 BUF *ReadDumpWithMaxSize(char *filename, UINT max_size); 338 BUF *ReadDumpW(wchar_t *filename); 339 BUF *ReadDumpExW(wchar_t *filename, bool read_lock); 340 BUF *CloneBuf(BUF *b); 341 BUF *MemToBuf(void *data, UINT size); 342 BUF *RandBuf(UINT size); 343 BUF *ReadRemainBuf(BUF *b); 344 UINT ReadBufRemainSize(BUF *b); 345 bool CompareBuf(BUF *b1, BUF *b2); 346 347 UINT PeekFifo(FIFO *f, void *p, UINT size); 348 UINT ReadFifo(FIFO *f, void *p, UINT size); 349 BUF *ReadFifoAll(FIFO *f); 350 void ShrinkFifoMemory(FIFO *f); 351 UCHAR *GetFifoPointer(FIFO *f); 352 UCHAR *FifoPtr(FIFO *f); 353 void WriteFifo(FIFO *f, void *p, UINT size); 354 void WriteFifoFront(FIFO *f, void *p, UINT size); 355 void PadFifoFront(FIFO *f, UINT size); 356 void ClearFifo(FIFO *f); 357 UINT FifoSize(FIFO *f); 358 void LockFifo(FIFO *f); 359 void UnlockFifo(FIFO *f); 360 void ReleaseFifo(FIFO *f); 361 void CleanupFifo(FIFO *f); 362 FIFO *NewFifo(); 363 FIFO *NewFifoFast(); 364 FIFO *NewFifoEx(bool fast); 365 FIFO *NewFifoEx2(bool fast, bool fixed); 366 void InitFifo(); 367 UINT GetFifoCurrentReallocMemSize(); 368 void SetFifoCurrentReallocMemSize(UINT size); 369 370 void *Search(LIST *o, void *target); 371 void Sort(LIST *o); 372 void SortEx(LIST *o, COMPARE *cmp); 373 void Add(LIST *o, void *p); 374 void AddDistinct(LIST *o, void *p); 375 void Insert(LIST *o, void *p); 376 void InsertDistinct(LIST *o, void *p); 377 bool Delete(LIST *o, void *p); 378 bool DeleteKey(LIST *o, UINT key); 379 void DeleteAll(LIST *o); 380 void LockList(LIST *o); 381 void UnlockList(LIST *o); 382 void ReleaseList(LIST *o); 383 void CleanupList(LIST *o); 384 LIST *NewList(COMPARE *cmp); 385 LIST *NewListFast(COMPARE *cmp); 386 LIST *NewListEx(COMPARE *cmp, bool fast); 387 LIST *NewListEx2(COMPARE *cmp, bool fast, bool fast_malloc); 388 LIST *NewListSingle(void *p); 389 void CopyToArray(LIST *o, void *p); 390 void *ToArray(LIST *o); 391 void *ToArrayEx(LIST *o, bool fast); 392 LIST *CloneList(LIST *o); 393 void SetCmp(LIST *o, COMPARE *cmp); 394 void SetSortFlag(LIST *o, bool sorted); 395 int CompareStr(void *p1, void *p2); 396 bool InsertStr(LIST *o, char *str); 397 int CompareUniStr(void *p1, void *p2); 398 bool IsInList(LIST *o, void *p); 399 bool IsInListKey(LIST *o, UINT key); 400 void *ListKeyToPointer(LIST *o, UINT key); 401 bool IsInListStr(LIST *o, char *str); 402 bool IsInListUniStr(LIST *o, wchar_t *str); 403 bool ReplaceListPointer(LIST *o, void *oldptr, void *newptr); 404 void AddInt(LIST *o, UINT i); 405 void AddInt64(LIST *o, UINT64 i); 406 void AddIntDistinct(LIST *o, UINT i); 407 void AddInt64Distinct(LIST *o, UINT64 i); 408 void DelInt(LIST *o, UINT i); 409 void DelInt64(LIST *o, UINT64 i); 410 void ReleaseIntList(LIST *o); 411 void ReleaseInt64List(LIST *o); 412 void DelAllInt(LIST *o); 413 bool IsIntInList(LIST *o, UINT i); 414 bool IsInt64InList(LIST *o, UINT64 i); 415 LIST *NewIntList(bool sorted); 416 LIST *NewInt64List(bool sorted); 417 int CompareInt(void *p1, void *p2); 418 int CompareInt64(void *p1, void *p2); 419 void InsertInt(LIST *o, UINT i); 420 void InsertInt64(LIST *o, UINT64 i); 421 void InsertIntDistinct(LIST *o, UINT i); 422 void InsertInt64Distinct(LIST *o, UINT64 i); 423 void RandomizeList(LIST *o); 424 425 void *GetNext(QUEUE *q); 426 void *GetNextWithLock(QUEUE *q); 427 void *PeekQueue(QUEUE *q); 428 void InsertQueue(QUEUE *q, void *p); 429 void InsertQueueWithLock(QUEUE *q, void *p); 430 void InsertQueueInt(QUEUE *q, UINT value); 431 void LockQueue(QUEUE *q); 432 void UnlockQueue(QUEUE *q); 433 void ReleaseQueue(QUEUE *q); 434 void CleanupQueue(QUEUE *q); 435 QUEUE *NewQueue(); 436 QUEUE *NewQueueFast(); 437 UINT GetQueueNum(QUEUE *q); 438 439 SK *NewSk(); 440 SK *NewSkEx(bool no_compact); 441 void ReleaseSk(SK *s); 442 void CleanupSk(SK *s); 443 void LockSk(SK *s); 444 void UnlockSk(SK *s); 445 void Push(SK *s, void *p); 446 void *Pop(SK *s); 447 448 UINT Uncompress(void *dst, UINT dst_size, void *src, UINT src_size); 449 UINT Compress(void *dst, UINT dst_size, void *src, UINT src_size); 450 UINT CompressEx(void *dst, UINT dst_size, void *src, UINT src_size, UINT level); 451 UINT CalcCompress(UINT src_size); 452 BUF *CompressBuf(BUF *src_buf); 453 BUF *UncompressBuf(BUF *src_buf); 454 455 bool IsZero(void *data, UINT size); 456 void FillBytes(void *data, UINT size, UCHAR c); 457 458 LIST *NewStrMap(); 459 void *StrMapSearch(LIST *map, char *key); 460 461 UINT SearchBin(void *data, UINT data_start, UINT data_size, void *key, UINT key_size); 462 void CrashNow(); 463 UINT Power(UINT a, UINT b); 464 465 void XorData(void *dst, void *src1, void *src2, UINT size); 466 467 SHARED_BUFFER *NewSharedBuffer(void *data, UINT size); 468 void ReleaseSharedBuffer(SHARED_BUFFER *b); 469 void CleanupSharedBuffer(SHARED_BUFFER *b); 470 471 void AppendBufUtf8(BUF *b, wchar_t *str); 472 void AppendBufStr(BUF *b, char *str); 473 474 LIST *NewStrList(); 475 void ReleaseStrList(LIST *o); 476 bool AddStrToStrListDistinct(LIST *o, char *str); 477 478 #endif // MEMORY_H 479 480