1 // SoftEther VPN Source Code - Stable Edition Repository 2 // Cedar Communication Module 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 // Logging.h 103 // Header of Logging.c 104 105 #ifndef LOGGING_H 106 #define LOGGING_H 107 108 109 // Port number for HTTP monitoring 110 #define LOG_HTTP_PORT 80 111 112 113 #define MAX_LOG_SIZE_DEFAULT 1073741823ULL 114 115 typedef char *(RECORD_PARSE_PROC)(RECORD *rec); 116 117 // Packet log structure 118 struct PACKET_LOG 119 { 120 CEDAR *Cedar; 121 struct PKT *Packet; 122 char *SrcSessionName; 123 char *DestSessionName; 124 bool WritePhysicalIP; 125 char SrcPhysicalIP[64]; 126 char DestPhysicalIP[64]; 127 bool PurePacket; // Packet not cloned 128 bool PurePacketNoPayload; // Packet not cloned (without payload) 129 SESSION *SrcSession; 130 bool NoLog; // Not to write a log 131 }; 132 133 // Log save options of the HUB 134 struct HUB_LOG 135 { 136 bool SaveSecurityLog; // To save the security log 137 UINT SecurityLogSwitchType; // Switching type of security log 138 bool SavePacketLog; // To save the packet log 139 UINT PacketLogSwitchType; // Switching type of packet log 140 UINT PacketLogConfig[NUM_PACKET_LOG]; // Packet log settings 141 }; 142 143 // Record 144 struct RECORD 145 { 146 UINT64 Tick; // Time 147 RECORD_PARSE_PROC *ParseProc; // Parsing procedure 148 void *Data; // Data 149 }; 150 151 // LOG object 152 struct LOG 153 { 154 LOCK *lock; // Lock 155 THREAD *Thread; // Thread 156 char *DirName; // Destination directory name 157 char *Prefix; // File name 158 UINT SwitchType; // Switching type of log file 159 QUEUE *RecordQueue; // Record queue 160 volatile bool Halt; // Halting flag 161 EVENT *Event; // Event for Log 162 EVENT *FlushEvent; // Flash completion event 163 bool CacheFlag; 164 UINT64 LastTick; 165 UINT LastSwitchType; 166 char LastStr[MAX_SIZE]; 167 UINT64 CurrentFilePointer; // The current file pointer 168 UINT CurrentLogNumber; // Log file number of the current 169 bool log_number_incremented; 170 }; 171 172 173 // ERASER object 174 struct ERASER 175 { 176 LOG *Log; // Logger 177 UINT64 MinFreeSpace; // Disk space to start deleting files 178 char *DirName; // Directory name 179 volatile bool Halt; // Halting flag 180 THREAD *Thread; // Thread 181 bool LastFailed; // Whether deletion of the file failed at the end 182 EVENT *HaltEvent; // Halting event 183 }; 184 185 // List of files that can be deleted 186 typedef struct ERASE_FILE 187 { 188 char *FullPath; // Full path 189 UINT64 UpdateTime; // Updating date 190 } ERASE_FILE; 191 192 // SYSLOG object 193 struct SLOG 194 { 195 LOCK *lock; // Lock 196 SOCK *Udp; // UDP socket 197 IP DestIp; // Destination IP address 198 UINT DestPort; // Destination port number 199 char HostName[MAX_HOST_NAME_LEN + 1]; // Host name 200 UINT64 NextPollIp; // Time of examination of the IP address at the end 201 }; 202 203 // Function prototype 204 LOG *NewLog(char *dir, char *prefix, UINT switch_type); 205 void FreeLog(LOG *g); 206 void LogThread(THREAD *thread, void *param); 207 void WaitLogFlush(LOG *g); 208 void LockLog(LOG *g); 209 void UnlockLog(LOG *g); 210 void InsertRecord(LOG *g, void *data, RECORD_PARSE_PROC *proc); 211 void InsertStringRecord(LOG *g, char *str); 212 void InsertUnicodeRecord(LOG *g, wchar_t *unistr); 213 char *StringRecordParseProc(RECORD *rec); 214 bool MakeLogFileName(LOG *g, char *name, UINT size, char *dir, char *prefix, UINT64 tick, UINT switch_type, UINT num, char *old_datestr); 215 void MakeLogFileNameStringFromTick(LOG *g, char *str, UINT size, UINT64 tick, UINT switch_type); 216 void WriteRecordToBuffer(BUF *b, RECORD *r); 217 void SetLogDirName(LOG *g, char *dir); 218 void SetLogPrefix(LOG *g, char *prefix); 219 void SetLogSwitchType(LOG *g, UINT switch_type); 220 bool PacketLog(HUB *hub, SESSION *src_session, SESSION *dest_session, PKT *packet, UINT64 now); 221 char *PacketLogParseProc(RECORD *rec); 222 UINT CalcPacketLoggingLevel(HUB *hub, PKT *packet); 223 UINT CalcPacketLoggingLevelEx(HUB_LOG *g, PKT *packet); 224 char *GenCsvLine(TOKEN_LIST *t); 225 void ReplaceForCsv(char *str); 226 char *PortStr(CEDAR *cedar, UINT port, bool udp); 227 char *TcpFlagStr(UCHAR flag); 228 void WriteSecurityLog(HUB *h, char *str); 229 void SecLog(HUB *h, char *fmt, ...); 230 void SiSetDefaultLogSetting(HUB_LOG *g); 231 void DebugLog(CEDAR *c, char *fmt, ...); 232 void HubLog(HUB *h, wchar_t *fmt, ...); 233 void ServerLog(CEDAR *c, wchar_t *fmt, ...); 234 void SLog(CEDAR *c, char *name, ...); 235 void WriteHubLog(HUB *h, wchar_t *str); 236 void HLog(HUB *h, char *name, ...); 237 void NLog(VH *v, char *name, ...); 238 void IPCLog(IPC *ipc, char *name, ...); 239 void PPPLog(PPP_SESSION *p, char *name, ...); 240 void IPsecLog(IKE_SERVER *ike, IKE_CLIENT *c, IKE_SA *ike_sa, IPSECSA *ipsec_sa, char *name, ...); 241 void EtherIPLog(ETHERIP_SERVER *s, char *name, ...); 242 void WriteServerLog(CEDAR *c, wchar_t *str); 243 void ALog(ADMIN *a, HUB *h, char *name, ...); 244 void CLog(CLIENT *c, char *name, ...); 245 void WriteClientLog(CLIENT *c, wchar_t *str); 246 ERASER *NewEraser(LOG *log, UINT64 min_size); 247 void FreeEraser(ERASER *e); 248 void ELog(ERASER *e, char *name, ...); 249 void EraserThread(THREAD *t, void *p); 250 void EraserMain(ERASER *e); 251 bool CheckEraserDiskFreeSpace(ERASER *e); 252 int CompareEraseFile(void *p1, void *p2); 253 LIST *GenerateEraseFileList(ERASER *e); 254 void FreeEraseFileList(LIST *o); 255 void PrintEraseFileList(LIST *o); 256 void EnumEraseFile(LIST *o, char *dirname); 257 SLOG *NewSysLog(char *hostname, UINT port); 258 void SetSysLog(SLOG *g, char *hostname, UINT port); 259 void FreeSysLog(SLOG *g); 260 void SendSysLog(SLOG *g, wchar_t *str); 261 void WriteMultiLineLog(LOG *g, BUF *b); 262 char *BuildHttpLogStr(HTTPLOG *h); 263 void MakeSafeLogStr(char *str); 264 void AddLogBufToStr(BUF *b, char *name, char *value); 265 void SetEraserCheckInterval(UINT interval); 266 UINT GetEraserCheckInterval(); 267 void SetMaxLogSize(UINT64 size); 268 UINT64 GetMaxLogSize(); 269 270 #endif // LOGGING_G 271 272