1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
|
// SoftEther VPN Source Code
// SeLow - SoftEther Lightweight Network Protocol
//
// SoftEther VPN Server, Client and Bridge are free software under GPLv2.
//
// Copyright (c) 2012-2014 Daiyuu Nobori.
// Copyright (c) 2012-2014 SoftEther VPN Project, University of Tsukuba, Japan.
// Copyright (c) 2012-2014 SoftEther Corporation.
//
// All Rights Reserved.
//
// http://www.softether.org/
//
// Author: Daiyuu Nobori
// Comments: Tetsuo Sugiyama, Ph.D.
//
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// version 2 as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License version 2
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// THE LICENSE AGREEMENT IS ATTACHED ON THE SOURCE-CODE PACKAGE
// AS "LICENSE.TXT" FILE. READ THE TEXT FILE IN ADVANCE TO USE THE SOFTWARE.
//
//
// THIS SOFTWARE IS DEVELOPED IN JAPAN, AND DISTRIBUTED FROM JAPAN,
// UNDER JAPANESE LAWS. YOU MUST AGREE IN ADVANCE TO USE, COPY, MODIFY,
// MERGE, PUBLISH, DISTRIBUTE, SUBLICENSE, AND/OR SELL COPIES OF THIS
// SOFTWARE, THAT ANY JURIDICAL DISPUTES WHICH ARE CONCERNED TO THIS
// SOFTWARE OR ITS CONTENTS, AGAINST US (SOFTETHER PROJECT, SOFTETHER
// CORPORATION, DAIYUU NOBORI OR OTHER SUPPLIERS), OR ANY JURIDICAL
// DISPUTES AGAINST US WHICH ARE CAUSED BY ANY KIND OF USING, COPYING,
// MODIFYING, MERGING, PUBLISHING, DISTRIBUTING, SUBLICENSING, AND/OR
// SELLING COPIES OF THIS SOFTWARE SHALL BE REGARDED AS BE CONSTRUED AND
// CONTROLLED BY JAPANESE LAWS, AND YOU MUST FURTHER CONSENT TO
// EXCLUSIVE JURISDICTION AND VENUE IN THE COURTS SITTING IN TOKYO,
// JAPAN. YOU MUST WAIVE ALL DEFENSES OF LACK OF PERSONAL JURISDICTION
// AND FORUM NON CONVENIENS. PROCESS MAY BE SERVED ON EITHER PARTY IN
// THE MANNER AUTHORIZED BY APPLICABLE LAW OR COURT RULE.
//
// USE ONLY IN JAPAN. DO NOT USE IT IN OTHER COUNTRIES. IMPORTING THIS
// SOFTWARE INTO OTHER COUNTRIES IS AT YOUR OWN RISK. SOME COUNTRIES
// PROHIBIT ENCRYPTED COMMUNICATIONS. USING THIS SOFTWARE IN OTHER
// COUNTRIES MIGHT BE RESTRICTED.
//
//
// SOURCE CODE CONTRIBUTION
// ------------------------
//
// Your contribution to SoftEther VPN Project is much appreciated.
// Please send patches to us through GitHub.
// Read the SoftEther VPN Patch Acceptance Policy in advance:
// http://www.softether.org/5-download/src/9.patch
//
//
// DEAR SECURITY EXPERTS
// ---------------------
//
// If you find a bug or a security vulnerability please kindly inform us
// about the problem immediately so that we can fix the security problem
// to protect a lot of users around the world as soon as possible.
//
// Our e-mail address for security reports is:
// softether-vpn-security [at] softether.org
//
// Please note that the above e-mail address is not a technical support
// inquiry address. If you need technical assistance, please visit
// http://www.softether.org/ and ask your question on the users forum.
//
// Thank you for your cooperation.
// SeLow.h
// Header of SeLow.c
#ifndef SELOW_H
#define SELOW_H
// Win32 DDK related
#ifndef CPU_64
#define _X86_
#else // CPU_64
#ifndef NEO_IA64
#define _AMD64_
#define AMD64
#else // NEO_IA64
#define _IA64_
#define IA64
#endif // NEO_IA64
#endif // CPU_64
#define NDIS_MINIPORT_DRIVER
// NDIS 6.2
#define NDIS620_MINIPORT
#define NDIS_SUPPORT_NDIS61 1
#define NDIS_SUPPORT_NDIS620 1
#define NEO_NDIS_MAJOR_VERSION 6
#define NEO_NDIS_MINOR_VERSION 20
#define NDIS_WDM 1
#include <wdm.h>
#include <wdmsec.h>
#include <ndis.h>
#include <stdio.h>
#include <string.h>
// OS determination
#ifdef WIN32
#define OS_WIN32 // Microsoft Windows
#else
#define OS_UNIX // UNIX / Linux
#endif
// Type declaration
#ifndef WINDOWS_H_INCLUDED
#ifndef WIN9X
typedef unsigned long BOOL;
#endif // WIN9X
#define TRUE 1
#define FALSE 0
#endif
typedef unsigned long bool;
#define true 1
#define false 0
typedef unsigned long long UINT64;
typedef signed long long INT64;
typedef unsigned short WORD;
typedef unsigned short USHORT;
typedef signed short SHORT;
typedef unsigned char BYTE;
typedef unsigned char UCHAR;
typedef signed char CHAR;
typedef unsigned long DWORD;
#define INFINITE 0xFFFFFFFF
#define LESS(a, max_value) ((a) < (max_value) ? (a) : (max_value))
#define MORE(a, min_value) ((a) > (min_value) ? (a) : (min_value))
#define INNER(a, b, c) (((b) <= (c) && (a) >= (b) && (a) <= (c)) || ((b) >= (c) && (a) >= (c) && (a) <= (b)))
#define OUTER(a, b, c) (!INNER((a), (b), (c)))
#define MAKESURE(a, b, c) (((b) <= (c)) ? (MORE(LESS((a), (c)), (b))) : (MORE(LESS((a), (b)), (c))))
#define MIN(a, b) ((a) >= (b) ? (b) : (a))
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define EQUAL_BOOL(a, b) (((a) && (b)) || ((!(a)) && (!(b))))
// Error checking macro
#define OK(val) ((val) == STATUS_SUCCESS)
#define NG(val) (!OK(val))
#define MAX_PATH 260
#define MAX_SIZE 512
#define STD_SIZE 512
#define SL_WHERE SlCrash(__LINE__, __LINE__, __LINE__, __LINE__)
#define SL_CRUSH(x) SlCrash(__LINE__, (UINT)(x), (UINT)(x), (UINT)(x))
// Common header
#include "SeLowCommon.h"
//// Utility data structure
// Lock
typedef struct SL_LOCK
{
NDIS_SPIN_LOCK spin_lock;
} SL_LOCK;
// Event
typedef struct SL_EVENT
{
KEVENT *event;
HANDLE event_handle;
} SL_EVENT;
// Unicode string
typedef struct SL_UNICODE
{
UNICODE_STRING String;
} SL_UNICODE;
// NDIS packet buffer
typedef struct SL_PACKET_BUFFER
{
NDIS_HANDLE NetBufferListPool; // NET_BUFFER_LIST Pool
NET_BUFFER_LIST *NetBufferList; // NET_BUFFER_LIST
} SL_PACKET_BUFFER;
// List
typedef struct SL_LIST
{
UINT num_item, num_reserved;
void **p;
SL_LOCK *lock;
} SL_LIST;
#define SL_LIST_DATA(o, i) (((o) != NULL) ? ((o)->p[(i)]) : NULL)
#define SL_LIST_NUM(o) (((o) != NULL) ? (o)->num_item : 0)
#define SL_INIT_NUM_RESERVED 32
//// SL data structure
// Packet queue
typedef struct SL_PACKET
{
UCHAR Data[SL_MAX_PACKET_SIZE]; // Data
UINT Size; // Size
struct SL_PACKET *Next; // Next packet
} SL_PACKET;
// File context
typedef struct SL_FILE
{
struct SL_DEVICE *Device; // Device
struct SL_ADAPTER *Adapter; // Adapter
FILE_OBJECT *FileObject; // File object
SL_EVENT *Event; // Event
char EventNameWin32[SL_EVENT_NAME_SIZE]; // Win32 event name
SL_LOCK *RecvLock; // Receive lock
SL_PACKET *RecvPacketHead; // Head of the received packet
SL_PACKET *RecvPacketTail; // Tail of the received packet
UINT NumRecvPackets; // Number of items of the received packet queue
NDIS_HANDLE NetBufferListPool; // NET_BUFFER_LIST Pool
volatile UINT NumSendingPacketets; // Number of packets being transmitted
bool SetEventFlag; // Flag to set an event
bool FinalWakeUp;
} SL_FILE;
// Device context
typedef struct SL_DEVICE
{
DEVICE_OBJECT *DeviceObject; // Device object
SL_UNICODE *DeviceName; // Device name
SL_UNICODE *SymbolicLinkName; // Symbolic link name
volatile bool Halting; // Halting
bool IsBasicDevice; // Whether basic device
struct SL_ADAPTER *Adapter; // Adapter
SL_LIST *FileList; // File List
SL_LOCK *OpenCloseLock; // Open / Close lock of the device
} SL_DEVICE;
// Adapter context
typedef struct SL_ADAPTER
{
volatile bool Halt; // Halt flag
volatile bool Ready; // Ready flag
SL_UNICODE *AdapterName; // Adapter name
NDIS_BIND_PARAMETERS BindParamCopy; // Copy of the bind parameters
UCHAR MacAddress[6]; // MAC address
UINT MtuSize; // MTU size
wchar_t AdapterId[SL_ADAPTER_ID_LEN]; // Adapter ID
volatile bool IsOpenPending; // Whether Open is Pending
volatile bool IsClosePending; // Whether Close is Pending
NDIS_HANDLE BindingContext; // Binding context
NDIS_HANDLE AdapterHandle; // Handle of the adapter
NDIS_HANDLE AdapterHandle2; // Handle of the adapter (receive-only)
NDIS_HANDLE UnbindContext; // Unbind context
SL_LOCK *Lock; // Lock object
volatile UINT NumPendingOidRequests; // Number of running OID requests
volatile UINT NumPendingSendPackets; // Number of packets being transmitted
UCHAR TmpBuffer[SL_MAX_PACKET_SIZE]; // Temporally buffer size
char FriendlyName[256]; // Adapter name
SL_DEVICE *Device; // Handle of the device
} SL_ADAPTER;
// SL context
typedef struct SL_CTX
{
DRIVER_OBJECT *DriverObject; // Driver object
NDIS_HANDLE ProtocolHandle; // NDIS protocol handle
SL_DEVICE *BasicDevice; // Basic device
SL_LIST *AdapterList; // Adapter list
volatile UINT IntCounter1;
UINT DummyInt;
volatile bool IsEnumCompleted; // Enumeration completion flag
volatile UINT NumBoundAdapters;
} SL_CTX;
//// SL function
NDIS_STATUS DriverEntry(DRIVER_OBJECT *driver_object, UNICODE_STRING *registry_path);
NTSTATUS SlDeviceOpenProc(DEVICE_OBJECT *device_object, IRP *irp);
NTSTATUS SlDeviceCloseProc(DEVICE_OBJECT *device_object, IRP *irp);
NTSTATUS SlDeviceReadProc(DEVICE_OBJECT *device_object, IRP *irp);
NTSTATUS SlDeviceWriteProc(DEVICE_OBJECT *device_object, IRP *irp);
NTSTATUS SlDeviceIoControlProc(DEVICE_OBJECT *device_object, IRP *irp);
void SlUnloadProc(DRIVER_OBJECT *driver_object);
NDIS_STATUS SlNdisBindAdapterExProc(NDIS_HANDLE protocol_driver_context, NDIS_HANDLE bind_context, NDIS_BIND_PARAMETERS *bind_parameters);
NDIS_STATUS SlNdisUnbindAdapterExProc(NDIS_HANDLE unbind_context, NDIS_HANDLE protocol_binding_context);
void SlNdisOpenAdapterCompleteExProc(NDIS_HANDLE protocol_binding_context, NDIS_STATUS status);
void SlNdisCloseAdapterCompleteExProc(NDIS_HANDLE protocol_binding_context);
NDIS_STATUS SlNdisNetPnPEventProc(NDIS_HANDLE protocol_binding_context, NET_PNP_EVENT_NOTIFICATION *net_pnp_event);
void SlNdisUninstallProc(void);
void SlNdisOidRequestCompleteProc(NDIS_HANDLE protocol_binding_context, NDIS_OID_REQUEST *oid_request, NDIS_STATUS status);
void SlNdisStatusExProc(NDIS_HANDLE protocol_binding_context, NDIS_STATUS_INDICATION *status_indication);
void SlNdisReceiveNetBufferListsProc(NDIS_HANDLE protocol_binding_context, NET_BUFFER_LIST *net_buffer_lists, NDIS_PORT_NUMBER port_number, ULONG NumberOfNetBufferLists, ULONG receive_flags);
void SlNdisSendNetBufferListsCompleteProc(NDIS_HANDLE protocol_binding_context, NET_BUFFER_LIST *net_buffer_lists, ULONG send_complete_flags);
SL_DEVICE *SlNewDevice(char *device_name, char *symbolic_link_name);
SL_DEVICE *SlNewDeviceUnicode(SL_UNICODE *u_device_name, SL_UNICODE *u_sym_name);
void SlFreeDevice(SL_DEVICE *dev);
void SlFreeAdapter(SL_ADAPTER *a);
void SlSendOidRequest(SL_ADAPTER *a, bool set, NDIS_OID oid, void *data, UINT size);
//// Utility function
void *SlMalloc(UINT size);
void *SlZeroMalloc(UINT size);
void SlFree(void *p);
void SlCopy(void *dst, void *src, UINT size);
void SlZero(void *dst, UINT size);
SL_LOCK *SlNewLock();
void SlLock(SL_LOCK *lock);
void SlUnlock(SL_LOCK *lock);
void SlFreeLock(SL_LOCK *lock);
SL_EVENT *SlNewEvent(char *name);
void SlFreeEvent(SL_EVENT *event);
void SlSet(SL_EVENT *event);
void SlReset(SL_EVENT *event);
SL_UNICODE *SlNewUnicode(char *str);
SL_UNICODE *SlNewUnicodeFromUnicodeString(UNICODE_STRING *src);
void SlFreeUnicode(SL_UNICODE *u);
NDIS_STRING *SlGetUnicode(SL_UNICODE *u);
SL_PACKET_BUFFER *SlNewPacketBuffer();
void SlFreePacketBuffer(SL_PACKET_BUFFER *p);
void SlCrash(UINT a, UINT b, UINT c, UINT d);
SL_LIST *SlNewList();
void SlAdd(SL_LIST *o, void *p);
bool SlDelete(SL_LIST *o, void *p);
void SlDeleteAll(SL_LIST *o);
void SlLockList(SL_LIST *o);
void SlUnlockList(SL_LIST *o);
void SlFreeList(SL_LIST *o);
void *SlClone(void *p, UINT size);
void SlSleep(int milliSeconds);
#endif // SELOW_H
// Developed by SoftEther VPN Project at University of Tsukuba in Japan.
// Department of Computer Science has dozens of overly-enthusiastic geeks.
// Join us: http://www.tsukuba.ac.jp/english/admission/
|