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 // EtherLog.h 103 // Header of EtherLog.c 104 105 #ifndef ETHERLOG_H 106 #define ETHERLOG_H 107 108 // Whether this is a beta version 109 #define ELOG_IS_BETA true 110 111 // Beta expiration date 112 #define ELOG_BETA_EXPIRES_YEAR 2008 113 #define ELOG_BETA_EXPIRES_MONTH 12 114 #define ELOG_BETA_EXPIRES_DAY 2 115 116 // Version information 117 //#define EL_VER 201 118 //#define EL_BUILD 1600 119 //#define EL_BETA 1 120 #define MAX_LOGGING_QUEUE_LEN 100000 121 122 // RPC related 123 struct RPC_ADD_DEVICE 124 { 125 char DeviceName[MAX_SIZE]; // Device name 126 HUB_LOG LogSetting; // Log settings 127 bool NoPromiscus; // Without promiscuous mode 128 }; 129 130 struct RPC_DELETE_DEVICE 131 { 132 char DeviceName[MAX_SIZE]; // Device name 133 }; 134 135 struct RPC_ENUM_DEVICE_ITEM 136 { 137 char DeviceName[MAX_SIZE]; // Device name 138 bool Active; // Running flag 139 }; 140 141 struct RPC_ENUM_DEVICE 142 { 143 UINT NumItem; // Number of items 144 RPC_ENUM_DEVICE_ITEM *Items; // Items 145 bool IsLicenseSupported; // Whether the license system is supported 146 }; 147 148 // License status of the service 149 struct RPC_EL_LICENSE_STATUS 150 { 151 BOOL Valid; // Enable flag 152 UINT64 SystemId; // System ID 153 UINT64 SystemExpires; // System expiration date 154 }; 155 156 // Device 157 struct EL_DEVICE 158 { 159 EL *el; // EL 160 char DeviceName[MAX_SIZE]; // Device name 161 HUB_LOG LogSetting; // Log settings 162 THREAD *Thread; // Thread 163 CANCEL *Cancel1; // Cancel 1 164 CANCEL *Cancel2; // Cancel 2 165 volatile bool Halt; // Halting flag 166 bool Active; // Running flag 167 bool NoPromiscus; // Without promiscuous mode 168 LOG *Logger; // Logger 169 }; 170 171 // License status 172 struct EL_LICENSE_STATUS 173 { 174 BOOL Valid; // Enable flag 175 UINT64 SystemId; // System ID 176 UINT64 Expires; // Expiration date 177 }; 178 179 // EtherLogger 180 struct EL 181 { 182 LOCK *lock; // Lock 183 REF *ref; // Reference counter 184 CEDAR *Cedar; // Cedar 185 LIST *DeviceList; // Device list 186 CFG_RW *CfgRw; // Config R/W 187 UINT Port; // Port number 188 LISTENER *Listener; // Listener 189 UCHAR HashedPassword[SHA1_SIZE]; // Password 190 LIST *AdminThreadList; // Management thread list 191 LIST *AdminSockList; // Management socket list 192 LICENSE_SYSTEM *LicenseSystem; // License system 193 EL_LICENSE_STATUS *LicenseStatus; // License status 194 UINT64 AutoDeleteCheckDiskFreeSpaceMin; // Minimum free disk space 195 ERASER *Eraser; // Eraser 196 }; 197 198 // Function prototype 199 void ElInit(); 200 void ElFree(); 201 void ElStart(); 202 void ElStop(); 203 EL *NewEl(); 204 void ReleaseEl(EL *e); 205 void CleanupEl(EL *e); 206 void ElInitConfig(EL *e); 207 void ElFreeConfig(EL *e); 208 bool ElLoadConfig(EL *e); 209 void ElLoadConfigFromFolder(EL *e, FOLDER *root); 210 void ElSaveConfig(EL *e); 211 void ElSaveConfigToFolder(EL *e, FOLDER *root); 212 int ElCompareDevice(void *p1, void *p2); 213 bool ElAddCaptureDevice(EL *e, char *name, HUB_LOG *log, bool no_promiscus); 214 bool ElDeleteCaptureDevice(EL *e, char *name); 215 bool ElSetCaptureDeviceLogSetting(EL *e, char *name, HUB_LOG *log); 216 void ElCaptureThread(THREAD *thread, void *param); 217 void ElStartListener(EL *e); 218 void ElStopListener(EL *e); 219 void ElListenerProc(THREAD *thread, void *param); 220 PACK *ElRpcServer(RPC *r, char *name, PACK *p); 221 void ElCheckLicense(EL_LICENSE_STATUS *st, LICENSE *e); 222 void ElParseCurrentLicenseStatus(LICENSE_SYSTEM *s, EL_LICENSE_STATUS *st); 223 bool ElIsBetaExpired(); 224 225 226 UINT EtAddDevice(EL *e, RPC_ADD_DEVICE *t); 227 UINT EtDelDevice(EL *e, RPC_DELETE_DEVICE *t); 228 UINT EtSetDevice(EL *e, RPC_ADD_DEVICE *t); 229 UINT EtGetDevice(EL *e, RPC_ADD_DEVICE *t); 230 UINT EtEnumDevice(EL *e, RPC_ENUM_DEVICE *t); 231 UINT EtEnumAllDevice(EL *e, RPC_ENUM_DEVICE *t); 232 UINT EtSetPassword(EL *e, RPC_SET_PASSWORD *t); 233 UINT EtAddLicenseKey(EL *a, RPC_TEST *t); 234 UINT EtDelLicenseKey(EL *a, RPC_TEST *t); 235 UINT EtEnumLicenseKey(EL *a, RPC_ENUM_LICENSE_KEY *t); 236 UINT EtGetLicenseStatus(EL *a, RPC_EL_LICENSE_STATUS *t); 237 UINT EtGetBridgeSupport(EL *a, RPC_BRIDGE_SUPPORT *t); 238 UINT EtRebootServer(EL *a, RPC_TEST *t); 239 240 UINT EcAddDevice(RPC *r, RPC_ADD_DEVICE *t); 241 UINT EcDelDevice(RPC *r, RPC_DELETE_DEVICE *t); 242 UINT EcSetDevice(RPC *r, RPC_ADD_DEVICE *t); 243 UINT EcGetDevice(RPC *r, RPC_ADD_DEVICE *t); 244 UINT EcEnumDevice(RPC *r, RPC_ENUM_DEVICE *t); 245 UINT EcEnumAllDevice(RPC *r, RPC_ENUM_DEVICE *t); 246 UINT EcSetPassword(RPC *r, RPC_SET_PASSWORD *t); 247 UINT EcAddLicenseKey(RPC *r, RPC_TEST *t); 248 UINT EcDelLicenseKey(RPC *r, RPC_TEST *t); 249 UINT EcEnumLicenseKey(RPC *r, RPC_ENUM_LICENSE_KEY *t); 250 UINT EcGetLicenseStatus(RPC *r, RPC_EL_LICENSE_STATUS *t); 251 UINT EcGetBridgeSupport(RPC *r, RPC_BRIDGE_SUPPORT *t); 252 UINT EcRebootServer(RPC *r, RPC_TEST *t); 253 254 UINT EcConnect(char *host, UINT port, char *password, RPC **rpc); 255 void EcDisconnect(RPC *rpc); 256 257 void InRpcAddDevice(RPC_ADD_DEVICE *t, PACK *p); 258 void OutRpcAddDevice(PACK *p, RPC_ADD_DEVICE *t); 259 void InRpcDeleteDevice(RPC_DELETE_DEVICE *t, PACK *p); 260 void OutRpcDeleteDevice(PACK *p, RPC_DELETE_DEVICE *t); 261 void InRpcEnumDevice(RPC_ENUM_DEVICE *t, PACK *p); 262 void OutRpcEnumDevice(PACK *p, RPC_ENUM_DEVICE *t); 263 void FreeRpcEnumDevice(RPC_ENUM_DEVICE *t); 264 void InRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY *t, PACK *p); 265 void OutRpcEnumLicenseKey(PACK *p, RPC_ENUM_LICENSE_KEY *t); 266 void FreeRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY *t); 267 void InRpcElLicenseStatus(RPC_EL_LICENSE_STATUS *t, PACK *p); 268 void OutRpcElLicenseStatus(PACK *p, RPC_EL_LICENSE_STATUS *t); 269 270 #endif // ETHERLOG_H 271 272 273