1 /**
2 * Windows API header module
3 *
4 * Translated from MinGW Windows headers
5 *
6 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
7 * Source: $(DRUNTIMESRC src/core/sys/windows/_ras.d)
8 */
9 module core.sys.windows.ras;
version(Windows)10 version (Windows):
11
12 version (ANSI) {} else version = Unicode;
13 pragma(lib, "rasapi32");
14
15 private import core.sys.windows.basetyps, core.sys.windows.lmcons, core.sys.windows.w32api, core.sys.windows.windef;
16
17 align(4):
18
19 enum RAS_MaxDeviceType = 16;
20 enum RAS_MaxPhoneNumber = 128;
21 enum RAS_MaxIpAddress = 15;
22 enum RAS_MaxIpxAddress = 21;
23 enum RAS_MaxEntryName = 256;
24 enum RAS_MaxDeviceName = 128;
25 enum RAS_MaxCallbackNumber = RAS_MaxPhoneNumber;
26 enum RAS_MaxAreaCode = 10;
27 enum RAS_MaxPadType = 32;
28 enum RAS_MaxX25Address = 200;
29 enum RAS_MaxFacilities = 200;
30 enum RAS_MaxUserData = 200;
31 enum RAS_MaxReplyMessage = 1024;
32
33 enum RDEOPT_UsePrefixSuffix = 0x00000001;
34 enum RDEOPT_PausedStates = 0x00000002;
35 enum RDEOPT_IgnoreModemSpeaker = 0x00000004;
36 enum RDEOPT_SetModemSpeaker = 0x00000008;
37 enum RDEOPT_IgnoreSoftwareCompression = 0x00000010;
38 enum RDEOPT_SetSoftwareCompression = 0x00000020;
39 enum RDEOPT_DisableConnectedUI = 0x00000040;
40 enum RDEOPT_DisableReconnectUI = 0x00000080;
41 enum RDEOPT_DisableReconnect = 0x00000100;
42 enum RDEOPT_NoUser = 0x00000200;
43 enum RDEOPT_PauseOnScript = 0x00000400;
44 enum RDEOPT_Router = 0x00000800;
45
46 enum REN_User = 0x00000000;
47 enum REN_AllUsers = 0x00000001;
48 enum VS_Default = 0;
49 enum VS_PptpOnly = 1;
50 enum VS_PptpFirst = 2;
51 enum VS_L2tpOnly = 3;
52 enum VS_L2tpFirst = 4;
53
54 enum RASDIALEVENT = "RasDialEvent";
55 enum WM_RASDIALEVENT = 0xCCCD;
56
57 enum RASEO_UseCountryAndAreaCodes = 0x00000001;
58 enum RASEO_SpecificIpAddr = 0x00000002;
59 enum RASEO_SpecificNameServers = 0x00000004;
60 enum RASEO_IpHeaderCompression = 0x00000008;
61 enum RASEO_RemoteDefaultGateway = 0x00000010;
62 enum RASEO_DisableLcpExtensions = 0x00000020;
63 enum RASEO_TerminalBeforeDial = 0x00000040;
64 enum RASEO_TerminalAfterDial = 0x00000080;
65 enum RASEO_ModemLights = 0x00000100;
66 enum RASEO_SwCompression = 0x00000200;
67 enum RASEO_RequireEncryptedPw = 0x00000400;
68 enum RASEO_RequireMsEncryptedPw = 0x00000800;
69 enum RASEO_RequireDataEncryption = 0x00001000;
70 enum RASEO_NetworkLogon = 0x00002000;
71 enum RASEO_UseLogonCredentials = 0x00004000;
72 enum RASEO_PromoteAlternates = 0x00008000;
73 enum RASNP_NetBEUI = 0x00000001;
74 enum RASNP_Ipx = 0x00000002;
75 enum RASNP_Ip = 0x00000004;
76 enum RASFP_Ppp = 0x00000001;
77 enum RASFP_Slip = 0x00000002;
78 enum RASFP_Ras = 0x00000004;
79
80 const TCHAR[]
81 RASDT_Modem = "modem",
82 RASDT_Isdn = "isdn",
83 RASDT_X25 = "x25",
84 RASDT_Vpn = "vpn",
85 RASDT_Pad = "pad",
86 RASDT_Generic = "GENERIC",
87 RASDT_Serial = "SERIAL",
88 RASDT_FrameRelay = "FRAMERELAY",
89 RASDT_Atm = "ATM",
90 RASDT_Sonet = "SONET",
91 RASDT_SW56 = "SW56",
92 RASDT_Irda = "IRDA",
93 RASDT_Parallel = "PARALLEL";
94
95 enum RASET_Phone = 1;
96 enum RASET_Vpn = 2;
97 enum RASET_Direct = 3;
98 enum RASET_Internet = 4;
99
100 static if (_WIN32_WINNT >= 0x401) {
101 enum RASEO_SecureLocalFiles = 0x00010000;
102 enum RASCN_Connection = 0x00000001;
103 enum RASCN_Disconnection = 0x00000002;
104 enum RASCN_BandwidthAdded = 0x00000004;
105 enum RASCN_BandwidthRemoved = 0x00000008;
106 enum RASEDM_DialAll = 1;
107 enum RASEDM_DialAsNeeded = 2;
108 enum RASIDS_Disabled = 0xffffffff;
109 enum RASIDS_UseGlobalValue = 0;
110 enum RASADFLG_PositionDlg = 0x00000001;
111 enum RASCM_UserName = 0x00000001;
112 enum RASCM_Password = 0x00000002;
113 enum RASCM_Domain = 0x00000004;
114 enum RASADP_DisableConnectionQuery = 0;
115 enum RASADP_LoginSessionDisable = 1;
116 enum RASADP_SavedAddressesLimit = 2;
117 enum RASADP_FailedConnectionTimeout = 3;
118 enum RASADP_ConnectionQueryTimeout = 4;
119 }
120 //static if (_WIN32_WINNT >= 0x500) {
121 enum RDEOPT_CustomDial = 0x00001000;
122 enum RASLCPAP_PAP = 0xC023;
123 enum RASLCPAP_SPAP = 0xC027;
124 enum RASLCPAP_CHAP = 0xC223;
125 enum RASLCPAP_EAP = 0xC227;
126 enum RASLCPAD_CHAP_MD5 = 0x05;
127 enum RASLCPAD_CHAP_MS = 0x80;
128 enum RASLCPAD_CHAP_MSV2 = 0x81;
129 enum RASLCPO_PFC = 0x00000001;
130 enum RASLCPO_ACFC = 0x00000002;
131 enum RASLCPO_SSHF = 0x00000004;
132 enum RASLCPO_DES_56 = 0x00000008;
133 enum RASLCPO_3_DES = 0x00000010;
134
135 enum RASCCPCA_MPPC = 0x00000006;
136 enum RASCCPCA_STAC = 0x00000005;
137
138 enum RASCCPO_Compression = 0x00000001;
139 enum RASCCPO_HistoryLess = 0x00000002;
140 enum RASCCPO_Encryption56bit = 0x00000010;
141 enum RASCCPO_Encryption40bit = 0x00000020;
142 enum RASCCPO_Encryption128bit = 0x00000040;
143
144 enum RASEO_RequireEAP = 0x00020000;
145 enum RASEO_RequirePAP = 0x00040000;
146 enum RASEO_RequireSPAP = 0x00080000;
147 enum RASEO_Custom = 0x00100000;
148 enum RASEO_PreviewPhoneNumber = 0x00200000;
149 enum RASEO_SharedPhoneNumbers = 0x00800000;
150 enum RASEO_PreviewUserPw = 0x01000000;
151 enum RASEO_PreviewDomain = 0x02000000;
152 enum RASEO_ShowDialingProgress = 0x04000000;
153 enum RASEO_RequireCHAP = 0x08000000;
154 enum RASEO_RequireMsCHAP = 0x10000000;
155 enum RASEO_RequireMsCHAP2 = 0x20000000;
156 enum RASEO_RequireW95MSCHAP = 0x40000000;
157 enum RASEO_CustomScript = 0x80000000;
158
159 enum RASIPO_VJ = 0x00000001;
160 enum RCD_SingleUser = 0;
161 enum RCD_AllUsers = 0x00000001;
162 enum RCD_Eap = 0x00000002;
163 enum RASEAPF_NonInteractive = 0x00000002;
164 enum RASEAPF_Logon = 0x00000004;
165 enum RASEAPF_Preview = 0x00000008;
166 enum ET_40Bit = 1;
167 enum ET_128Bit = 2;
168 enum ET_None = 0;
169 enum ET_Require = 1;
170 enum ET_RequireMax = 2;
171 enum ET_Optional = 3;
172 //}
173
174 enum RASCS_PAUSED = 0x1000;
175 enum RASCS_DONE = 0x2000;
176 enum RASCONNSTATE {
177 RASCS_OpenPort = 0,
178 RASCS_PortOpened,
179 RASCS_ConnectDevice,
180 RASCS_DeviceConnected,
181 RASCS_AllDevicesConnected,
182 RASCS_Authenticate,
183 RASCS_AuthNotify,
184 RASCS_AuthRetry,
185 RASCS_AuthCallback,
186 RASCS_AuthChangePassword,
187 RASCS_AuthProject,
188 RASCS_AuthLinkSpeed,
189 RASCS_AuthAck,
190 RASCS_ReAuthenticate,
191 RASCS_Authenticated,
192 RASCS_PrepareForCallback,
193 RASCS_WaitForModemReset,
194 RASCS_WaitForCallback,
195 RASCS_Projected,
196 RASCS_StartAuthentication,
197 RASCS_CallbackComplete,
198 RASCS_LogonNetwork,
199 RASCS_SubEntryConnected,
200 RASCS_SubEntryDisconnected,
201 RASCS_Interactive = RASCS_PAUSED,
202 RASCS_RetryAuthentication,
203 RASCS_CallbackSetByCaller,
204 RASCS_PasswordExpired,
205 // static if (_WIN32_WINNT >= 0x500) {
206 RASCS_InvokeEapUI,
207 // }
208 RASCS_Connected = RASCS_DONE,
209 RASCS_Disconnected
210 }
211 alias RASCONNSTATE* LPRASCONNSTATE;
212
213 enum RASPROJECTION {
214 RASP_Amb = 0x10000,
215 RASP_PppNbf = 0x803F,
216 RASP_PppIpx = 0x802B,
217 RASP_PppIp = 0x8021,
218 // static if (_WIN32_WINNT >= 0x500) {
219 RASP_PppCcp = 0x80FD,
220 // }
221 RASP_PppLcp = 0xC021,
222 RASP_Slip = 0x20000
223 }
224 alias RASPROJECTION* LPRASPROJECTION;
225
226 alias TypeDef!(HANDLE) HRASCONN;
227 alias HRASCONN* LPHRASCONN;
228
229 struct RASCONNW {
230 align(4):
231 DWORD dwSize;
232 HRASCONN hrasconn;
233 align {
234 WCHAR[RAS_MaxEntryName + 1] szEntryName = 0;
235 WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
236 WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
237 }
238 //static if (_WIN32_WINNT >= 0x401) {
239 WCHAR[MAX_PATH] szPhonebook = 0;
240 DWORD dwSubEntry;
241 //}
242 //static if (_WIN32_WINNT >= 0x500) {
243 GUID guidEntry;
244 //}
245 static if (_WIN32_WINNT >= 0x501) {
246 DWORD dwFlags;
247 LUID luid;
248 }
249 }
250 alias RASCONNW* LPRASCONNW;
251
252 struct RASCONNA {
253 align(4):
254 DWORD dwSize;
255 HRASCONN hrasconn;
256 align {
257 CHAR[RAS_MaxEntryName + 1] szEntryName = 0;
258 CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
259 CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
260 }
261 //static if (_WIN32_WINNT >= 0x401) {
262 CHAR[MAX_PATH] szPhonebook = 0;
263 DWORD dwSubEntry;
264 //}
265 //static if (_WIN32_WINNT >= 0x500) {
266 GUID guidEntry;
267 //}
268 static if (_WIN32_WINNT >= 0x501) {
269 DWORD dwFlags;
270 LUID luid;
271 }
272 }
273 alias RASCONNA* LPRASCONNA;
274
275 struct RASCONNSTATUSW {
276 DWORD dwSize;
277 RASCONNSTATE rasconnstate;
278 DWORD dwError;
279 WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
280 WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
281 static if (_WIN32_WINNT >= 0x401) {
282 WCHAR[RAS_MaxPhoneNumber + 1] szPhoneNumber = 0;
283 }
284 }
285 alias RASCONNSTATUSW* LPRASCONNSTATUSW;
286
287 struct RASCONNSTATUSA {
288 DWORD dwSize;
289 RASCONNSTATE rasconnstate;
290 DWORD dwError;
291 CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
292 CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
293 static if (_WIN32_WINNT >= 0x401) {
294 CHAR[RAS_MaxPhoneNumber + 1] szPhoneNumber = 0;
295 }
296 }
297 alias RASCONNSTATUSA* LPRASCONNSTATUSA;
298
299 struct RASDIALPARAMSW {
300 align(4):
301 DWORD dwSize;
302 align {
303 WCHAR[RAS_MaxEntryName + 1] szEntryName = 0;
304 WCHAR[RAS_MaxPhoneNumber + 1] szPhoneNumber = 0;
305 WCHAR[RAS_MaxCallbackNumber + 1] szCallbackNumber = 0;
306 WCHAR[UNLEN + 1] szUserName = 0;
307 WCHAR[PWLEN + 1] szPassword = 0;
308 WCHAR[DNLEN + 1] szDomain = 0;
309 }
310 static if (_WIN32_WINNT >= 0x401) {
311 DWORD dwSubEntry;
312 ULONG_PTR dwCallbackId;
313 }
314 }
315 alias RASDIALPARAMSW* LPRASDIALPARAMSW;
316
317 struct RASDIALPARAMSA{
318 align(4):
319 DWORD dwSize;
320 align {
321 CHAR[RAS_MaxEntryName + 1] szEntryName = 0;
322 CHAR[RAS_MaxPhoneNumber + 1] szPhoneNumber = 0;
323 CHAR[RAS_MaxCallbackNumber + 1] szCallbackNumber = 0;
324 CHAR[UNLEN + 1] szUserName = 0;
325 CHAR[PWLEN + 1] szPassword = 0;
326 CHAR[DNLEN + 1] szDomain = 0;
327 }
328 static if (_WIN32_WINNT >= 0x401) {
329 DWORD dwSubEntry;
330 ULONG_PTR dwCallbackId;
331 }
332 }
333 alias RASDIALPARAMSA* LPRASDIALPARAMSA;
334
335 //static if (_WIN32_WINNT >= 0x500) {
336 struct RASEAPINFO {
337 align(4):
338 DWORD dwSizeofEapInfo;
339 BYTE *pbEapInfo;
340 }
341 //}
342
343 struct RASDIALEXTENSIONS {
344 align(4):
345 DWORD dwSize;
346 DWORD dwfOptions;
347 HWND hwndParent;
348 ULONG_PTR reserved;
349 //static if (_WIN32_WINNT >= 0x500) {
350 ULONG_PTR reserved1;
351 RASEAPINFO RasEapInfo;
352 //}
353 }
354 alias RASDIALEXTENSIONS* LPRASDIALEXTENSIONS;
355
356 struct RASENTRYNAMEW {
357 DWORD dwSize;
358 WCHAR[RAS_MaxEntryName + 1] szEntryName = 0;
359 //static if (_WIN32_WINNT >= 0x500) {
360 DWORD dwFlags;
361 WCHAR[MAX_PATH + 1] szPhonebookPath = 0;
362 //}
363 }
364 alias RASENTRYNAMEW* LPRASENTRYNAMEW;
365
366 struct RASENTRYNAMEA{
367 DWORD dwSize;
368 CHAR[RAS_MaxEntryName + 1] szEntryName = 0;
369 //static if (_WIN32_WINNT >= 0x500) {
370 DWORD dwFlags;
371 CHAR[MAX_PATH + 1] szPhonebookPath = 0;
372 //}
373 }
374 alias RASENTRYNAMEA* LPRASENTRYNAMEA;
375
376 struct RASAMBW{
377 DWORD dwSize;
378 DWORD dwError;
379 WCHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0;
380 BYTE bLana;
381 }
382 alias RASAMBW* LPRASAMBW;
383
384 struct RASAMBA{
385 DWORD dwSize;
386 DWORD dwError;
387 CHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0;
388 BYTE bLana;
389 }
390 alias RASAMBA* LPRASAMBA;
391
392 struct RASPPPNBFW{
393 DWORD dwSize;
394 DWORD dwError;
395 DWORD dwNetBiosError;
396 WCHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0;
397 WCHAR[NETBIOS_NAME_LEN + 1] szWorkstationName = 0;
398 BYTE bLana;
399 }
400 alias RASPPPNBFW* LPRASPPPNBFW;
401
402 struct RASPPPNBFA{
403 DWORD dwSize;
404 DWORD dwError;
405 DWORD dwNetBiosError;
406 CHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0;
407 CHAR[NETBIOS_NAME_LEN + 1] szWorkstationName = 0;
408 BYTE bLana;
409 }
410 alias RASPPPNBFA* LPRASPPPNBFA;
411
412 struct RASPPPIPXW {
413 DWORD dwSize;
414 DWORD dwError;
415 WCHAR[RAS_MaxIpxAddress + 1] szIpxAddress = 0;
416 }
417 alias RASPPPIPXW* LPRASPPPIPXW;
418
419 struct RASPPPIPXA {
420 DWORD dwSize;
421 DWORD dwError;
422 CHAR[RAS_MaxIpxAddress + 1] szIpxAddress = 0;
423 }
424 alias RASPPPIPXA* LPRASPPPIPXA;
425
426 struct RASPPPIPW{
427 DWORD dwSize;
428 DWORD dwError;
429 WCHAR[RAS_MaxIpAddress + 1] szIpAddress = 0;
430 //#ifndef WINNT35COMPATIBLE
431 WCHAR[RAS_MaxIpAddress + 1] szServerIpAddress = 0;
432 //#endif
433 //static if (_WIN32_WINNT >= 0x500) {
434 DWORD dwOptions;
435 DWORD dwServerOptions;
436 //}
437 }
438 alias RASPPPIPW* LPRASPPPIPW;
439
440 struct RASPPPIPA{
441 DWORD dwSize;
442 DWORD dwError;
443 CHAR[RAS_MaxIpAddress + 1] szIpAddress = 0;
444 //#ifndef WINNT35COMPATIBLE
445 CHAR[RAS_MaxIpAddress + 1] szServerIpAddress = 0;
446 //#endif
447 //static if (_WIN32_WINNT >= 0x500) {
448 DWORD dwOptions;
449 DWORD dwServerOptions;
450 //}
451 }
452 alias RASPPPIPA* LPRASPPPIPA;
453
454 struct RASPPPLCPW{
455 DWORD dwSize;
456 BOOL fBundled;
457 //static if (_WIN32_WINNT >= 0x500) {
458 DWORD dwError;
459 DWORD dwAuthenticationProtocol;
460 DWORD dwAuthenticationData;
461 DWORD dwEapTypeId;
462 DWORD dwServerAuthenticationProtocol;
463 DWORD dwServerAuthenticationData;
464 DWORD dwServerEapTypeId;
465 BOOL fMultilink;
466 DWORD dwTerminateReason;
467 DWORD dwServerTerminateReason;
468 WCHAR[RAS_MaxReplyMessage] szReplyMessage = 0;
469 DWORD dwOptions;
470 DWORD dwServerOptions;
471 //}
472 }
473 alias RASPPPLCPW* LPRASPPPLCPW;
474
475 struct RASPPPLCPA{
476 DWORD dwSize;
477 BOOL fBundled;
478 //static if (_WIN32_WINNT >= 0x500) {
479 DWORD dwError;
480 DWORD dwAuthenticationProtocol;
481 DWORD dwAuthenticationData;
482 DWORD dwEapTypeId;
483 DWORD dwServerAuthenticationProtocol;
484 DWORD dwServerAuthenticationData;
485 DWORD dwServerEapTypeId;
486 BOOL fMultilink;
487 DWORD dwTerminateReason;
488 DWORD dwServerTerminateReason;
489 CHAR[RAS_MaxReplyMessage] szReplyMessage = 0;
490 DWORD dwOptions;
491 DWORD dwServerOptions;
492 //}
493 }
494 alias RASPPPLCPA* LPRASPPPLCPA;
495
496 struct RASSLIPW{
497 DWORD dwSize;
498 DWORD dwError;
499 WCHAR[RAS_MaxIpAddress + 1] szIpAddress = 0;
500 }
501 alias RASSLIPW* LPRASSLIPW;
502
503 struct RASSLIPA{
504 DWORD dwSize;
505 DWORD dwError;
506 CHAR[RAS_MaxIpAddress + 1] szIpAddress = 0;
507 }
508 alias RASSLIPA* LPRASSLIPA;
509
510 struct RASDEVINFOW{
511 DWORD dwSize;
512 WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
513 WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
514 }
515 alias RASDEVINFOW* LPRASDEVINFOW;
516
517 struct RASDEVINFOA{
518 DWORD dwSize;
519 CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
520 CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
521 }
522 alias RASDEVINFOA* LPRASDEVINFOA;
523
524 struct RASCTRYINFO {
525 DWORD dwSize;
526 DWORD dwCountryID;
527 DWORD dwNextCountryID;
528 DWORD dwCountryCode;
529 DWORD dwCountryNameOffset;
530 }
531 alias RASCTRYINFO* LPRASCTRYINFO;
532 alias RASCTRYINFO RASCTRYINFOW, RASCTRYINFOA;
533 alias RASCTRYINFOW* LPRASCTRYINFOW;
534 alias RASCTRYINFOA* LPRASCTRYINFOA;
535
536 struct RASIPADDR {
537 BYTE a;
538 BYTE b;
539 BYTE c;
540 BYTE d;
541 }
542
543 struct RASENTRYW {
544 DWORD dwSize;
545 DWORD dwfOptions;
546 DWORD dwCountryID;
547 DWORD dwCountryCode;
548 WCHAR[RAS_MaxAreaCode + 1] szAreaCode = 0;
549 WCHAR[RAS_MaxPhoneNumber + 1] szLocalPhoneNumber = 0;
550 DWORD dwAlternateOffset;
551 RASIPADDR ipaddr;
552 RASIPADDR ipaddrDns;
553 RASIPADDR ipaddrDnsAlt;
554 RASIPADDR ipaddrWins;
555 RASIPADDR ipaddrWinsAlt;
556 DWORD dwFrameSize;
557 DWORD dwfNetProtocols;
558 DWORD dwFramingProtocol;
559 WCHAR[MAX_PATH] szScript = 0;
560 WCHAR[MAX_PATH] szAutodialDll = 0;
561 WCHAR[MAX_PATH] szAutodialFunc = 0;
562 WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
563 WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
564 WCHAR[RAS_MaxPadType + 1] szX25PadType = 0;
565 WCHAR[RAS_MaxX25Address + 1] szX25Address = 0;
566 WCHAR[RAS_MaxFacilities + 1] szX25Facilities = 0;
567 WCHAR[RAS_MaxUserData + 1] szX25UserData = 0;
568 DWORD dwChannels;
569 DWORD dwReserved1;
570 DWORD dwReserved2;
571 //static if (_WIN32_WINNT >= 0x401) {
572 DWORD dwSubEntries;
573 DWORD dwDialMode;
574 DWORD dwDialExtraPercent;
575 DWORD dwDialExtraSampleSeconds;
576 DWORD dwHangUpExtraPercent;
577 DWORD dwHangUpExtraSampleSeconds;
578 DWORD dwIdleDisconnectSeconds;
579 //}
580 //static if (_WIN32_WINNT >= 0x500) {
581 DWORD dwType;
582 DWORD dwEncryptionType;
583 DWORD dwCustomAuthKey;
584 GUID guidId;
585 WCHAR[MAX_PATH] szCustomDialDll = 0;
586 DWORD dwVpnStrategy;
587 //}
588 }
589 alias RASENTRYW* LPRASENTRYW;
590
591 struct RASENTRYA {
592 DWORD dwSize;
593 DWORD dwfOptions;
594 DWORD dwCountryID;
595 DWORD dwCountryCode;
596 CHAR[RAS_MaxAreaCode + 1] szAreaCode = 0;
597 CHAR[RAS_MaxPhoneNumber + 1] szLocalPhoneNumber = 0;
598 DWORD dwAlternateOffset;
599 RASIPADDR ipaddr;
600 RASIPADDR ipaddrDns;
601 RASIPADDR ipaddrDnsAlt;
602 RASIPADDR ipaddrWins;
603 RASIPADDR ipaddrWinsAlt;
604 DWORD dwFrameSize;
605 DWORD dwfNetProtocols;
606 DWORD dwFramingProtocol;
607 CHAR[MAX_PATH] szScript = 0;
608 CHAR[MAX_PATH] szAutodialDll = 0;
609 CHAR[MAX_PATH] szAutodialFunc = 0;
610 CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
611 CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
612 CHAR[RAS_MaxPadType + 1] szX25PadType = 0;
613 CHAR[RAS_MaxX25Address + 1] szX25Address = 0;
614 CHAR[RAS_MaxFacilities + 1] szX25Facilities = 0;
615 CHAR[RAS_MaxUserData + 1] szX25UserData = 0;
616 DWORD dwChannels;
617 DWORD dwReserved1;
618 DWORD dwReserved2;
619 //static if (_WIN32_WINNT >= 0x401) {
620 DWORD dwSubEntries;
621 DWORD dwDialMode;
622 DWORD dwDialExtraPercent;
623 DWORD dwDialExtraSampleSeconds;
624 DWORD dwHangUpExtraPercent;
625 DWORD dwHangUpExtraSampleSeconds;
626 DWORD dwIdleDisconnectSeconds;
627 //}
628 //static if (_WIN32_WINNT >= 0x500) {
629 DWORD dwType;
630 DWORD dwEncryptionType;
631 DWORD dwCustomAuthKey;
632 GUID guidId;
633 CHAR[MAX_PATH] szCustomDialDll = 0;
634 DWORD dwVpnStrategy;
635 //}
636 }
637 alias RASENTRYA* LPRASENTRYA;
638
639
640 //static if (_WIN32_WINNT >= 0x401) {
641 struct RASADPARAMS {
642 align(4):
643 DWORD dwSize;
644 HWND hwndOwner;
645 DWORD dwFlags;
646 LONG xDlg;
647 LONG yDlg;
648 }
649 alias RASADPARAMS* LPRASADPARAMS;
650
651 struct RASSUBENTRYW{
652 DWORD dwSize;
653 DWORD dwfFlags;
654 WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
655 WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
656 WCHAR[RAS_MaxPhoneNumber + 1] szLocalPhoneNumber = 0;
657 DWORD dwAlternateOffset;
658 }
659 alias RASSUBENTRYW* LPRASSUBENTRYW;
660
661 struct RASSUBENTRYA{
662 DWORD dwSize;
663 DWORD dwfFlags;
664 CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
665 CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
666 CHAR[RAS_MaxPhoneNumber + 1] szLocalPhoneNumber = 0;
667 DWORD dwAlternateOffset;
668 }
669 alias RASSUBENTRYA* LPRASSUBENTRYA;
670
671 struct RASCREDENTIALSW{
672 DWORD dwSize;
673 DWORD dwMask;
674 WCHAR[UNLEN + 1] szUserName = 0;
675 WCHAR[PWLEN + 1] szPassword = 0;
676 WCHAR[DNLEN + 1] szDomain = 0;
677 }
678 alias RASCREDENTIALSW* LPRASCREDENTIALSW;
679
680 struct RASCREDENTIALSA{
681 DWORD dwSize;
682 DWORD dwMask;
683 CHAR[UNLEN + 1] szUserName = 0;
684 CHAR[PWLEN + 1] szPassword = 0;
685 CHAR[DNLEN + 1] szDomain = 0;
686 }
687 alias RASCREDENTIALSA* LPRASCREDENTIALSA;
688
689 struct RASAUTODIALENTRYW{
690 DWORD dwSize;
691 DWORD dwFlags;
692 DWORD dwDialingLocation;
693 WCHAR[RAS_MaxEntryName + 1] szEntry = 0;
694 }
695 alias RASAUTODIALENTRYW* LPRASAUTODIALENTRYW;
696
697 struct RASAUTODIALENTRYA{
698 DWORD dwSize;
699 DWORD dwFlags;
700 DWORD dwDialingLocation;
701 CHAR[RAS_MaxEntryName + 1] szEntry = 0;
702 }
703 alias RASAUTODIALENTRYA* LPRASAUTODIALENTRYA;
704 //}
705
706 //static if (_WIN32_WINNT >= 0x500) {
707 struct RASPPPCCP{
708 DWORD dwSize;
709 DWORD dwError;
710 DWORD dwCompressionAlgorithm;
711 DWORD dwOptions;
712 DWORD dwServerCompressionAlgorithm;
713 DWORD dwServerOptions;
714 }
715 alias RASPPPCCP* LPRASPPPCCP;
716
717 struct RASEAPUSERIDENTITYW{
718 WCHAR[UNLEN + 1] szUserName = 0;
719 DWORD dwSizeofEapInfo;
720 BYTE[1] pbEapInfo;
721 }
722 alias RASEAPUSERIDENTITYW* LPRASEAPUSERIDENTITYW;
723
724 struct RASEAPUSERIDENTITYA{
725 CHAR[UNLEN + 1] szUserName = 0;
726 DWORD dwSizeofEapInfo;
727 BYTE[1] pbEapInfo;
728 }
729 alias RASEAPUSERIDENTITYA* LPRASEAPUSERIDENTITYA;
730
731 struct RAS_STATS{
732 DWORD dwSize;
733 DWORD dwBytesXmited;
734 DWORD dwBytesRcved;
735 DWORD dwFramesXmited;
736 DWORD dwFramesRcved;
737 DWORD dwCrcErr;
738 DWORD dwTimeoutErr;
739 DWORD dwAlignmentErr;
740 DWORD dwHardwareOverrunErr;
741 DWORD dwFramingErr;
742 DWORD dwBufferOverrunErr;
743 DWORD dwCompressionRatioIn;
744 DWORD dwCompressionRatioOut;
745 DWORD dwBps;
746 DWORD dwConnectDuration;
747 }
748 alias RAS_STATS* PRAS_STATS;
749 //}
750
751
752 /* UNICODE typedefs for structures*/
version(Unicode)753 version (Unicode) {
754 alias RASCONNW RASCONN;
755 alias RASENTRYW RASENTRY;
756 alias RASCONNSTATUSW RASCONNSTATUS;
757 alias RASDIALPARAMSW RASDIALPARAMS;
758 alias RASAMBW RASAMB;
759 alias RASPPPNBFW RASPPPNBF;
760 alias RASPPPIPXW RASPPPIPX;
761 alias RASPPPIPW RASPPPIP;
762 alias RASPPPLCPW RASPPPLCP;
763 alias RASSLIPW RASSLIP;
764 alias RASDEVINFOW RASDEVINFO;
765 alias RASENTRYNAMEW RASENTRYNAME;
766
767 //static if (_WIN32_WINNT >= 0x401) {
768 alias RASSUBENTRYW RASSUBENTRY;
769 alias RASCREDENTIALSW RASCREDENTIALS;
770 alias RASAUTODIALENTRYW RASAUTODIALENTRY;
771 //}
772
773 //static if (_WIN32_WINNT >= 0x500) {
774 alias RASEAPUSERIDENTITYW RASEAPUSERIDENTITY;
775 //}
776
777 } else { // ! defined UNICODE
778
779 alias RASCONNA RASCONN;
780 alias RASENTRYA RASENTRY;
781 alias RASCONNSTATUSA RASCONNSTATUS;
782 alias RASDIALPARAMSA RASDIALPARAMS;
783 alias RASAMBA RASAMB;
784 alias RASPPPNBFA RASPPPNBF;
785 alias RASPPPIPXA RASPPPIPX;
786 alias RASPPPIPA RASPPPIP;
787 alias RASPPPLCPA RASPPPLCP;
788 alias RASSLIPA RASSLIP;
789 alias RASDEVINFOA RASDEVINFO;
790 alias RASENTRYNAMEA RASENTRYNAME;
791
792 //static if (_WIN32_WINNT >= 0x401) {
793 alias RASSUBENTRYA RASSUBENTRY;
794 alias RASCREDENTIALSA RASCREDENTIALS;
795 alias RASAUTODIALENTRYA RASAUTODIALENTRY;
796 //}
797 //static if (_WIN32_WINNT >= 0x500) {
798 alias RASEAPUSERIDENTITYA RASEAPUSERIDENTITY;
799 //}
800 }// ! UNICODE
801
802
803 alias RASCONN* LPRASCONN;
804 alias RASENTRY* LPRASENTRY;
805 alias RASCONNSTATUS* LPRASCONNSTATUS;
806 alias RASDIALPARAMS* LPRASDIALPARAMS;
807 alias RASAMB* LPRASAM;
808 alias RASPPPNBF* LPRASPPPNBF;
809 alias RASPPPIPX* LPRASPPPIPX;
810 alias RASPPPIP* LPRASPPPIP;
811 alias RASPPPLCP* LPRASPPPLCP;
812 alias RASSLIP* LPRASSLIP;
813 alias RASDEVINFO* LPRASDEVINFO;
814 alias RASENTRYNAME* LPRASENTRYNAME;
815
816 //static if (_WIN32_WINNT >= 0x401) {
817 alias RASSUBENTRY* LPRASSUBENTRY;
818 alias RASCREDENTIALS* LPRASCREDENTIALS;
819 alias RASAUTODIALENTRY* LPRASAUTODIALENTRY;
820 //}
821 //static if (_WIN32_WINNT >= 0x500) {
822 alias RASEAPUSERIDENTITY* LPRASEAPUSERIDENTITY;
823 //}
824
825 /* Callback prototypes */
826 extern (Windows) { /* WINAPI */
827 deprecated {
828 alias BOOL function (HWND, LPSTR, DWORD, LPDWORD) ORASADFUNC;
829 }
830
831 alias void function (UINT, RASCONNSTATE, DWORD) RASDIALFUNC;
832 alias void function(HRASCONN, UINT, RASCONNSTATE, DWORD, DWORD) RASDIALFUNC1;
833 alias DWORD function (ULONG_PTR, DWORD, HRASCONN, UINT,
834 RASCONNSTATE, DWORD, DWORD) RASDIALFUNC2;
835
836 /* External functions */
837 DWORD RasDialA(LPRASDIALEXTENSIONS, LPCSTR, LPRASDIALPARAMSA, DWORD, LPVOID, LPHRASCONN);
838 DWORD RasDialW(LPRASDIALEXTENSIONS, LPCWSTR, LPRASDIALPARAMSW, DWORD, LPVOID, LPHRASCONN);
839 DWORD RasEnumConnectionsA(LPRASCONNA, LPDWORD, LPDWORD);
840 DWORD RasEnumConnectionsW(LPRASCONNW, LPDWORD, LPDWORD);
841 DWORD RasEnumEntriesA(LPCSTR, LPCSTR, LPRASENTRYNAMEA, LPDWORD, LPDWORD);
842 DWORD RasEnumEntriesW(LPCWSTR, LPCWSTR, LPRASENTRYNAMEW, LPDWORD, LPDWORD);
843 DWORD RasGetConnectStatusA(HRASCONN, LPRASCONNSTATUSA);
844 DWORD RasGetConnectStatusW(HRASCONN, LPRASCONNSTATUSW);
845 DWORD RasGetErrorStringA(UINT, LPSTR, DWORD);
846 DWORD RasGetErrorStringW(UINT, LPWSTR, DWORD);
847 DWORD RasHangUpA(HRASCONN);
848 DWORD RasHangUpW(HRASCONN);
849 DWORD RasGetProjectionInfoA(HRASCONN, RASPROJECTION, LPVOID, LPDWORD);
850 DWORD RasGetProjectionInfoW(HRASCONN, RASPROJECTION, LPVOID, LPDWORD);
851 DWORD RasCreatePhonebookEntryA(HWND, LPCSTR);
852 DWORD RasCreatePhonebookEntryW(HWND, LPCWSTR);
853 DWORD RasEditPhonebookEntryA(HWND, LPCSTR, LPCSTR);
854 DWORD RasEditPhonebookEntryW(HWND, LPCWSTR, LPCWSTR);
855 DWORD RasSetEntryDialParamsA(LPCSTR, LPRASDIALPARAMSA, BOOL);
856 DWORD RasSetEntryDialParamsW(LPCWSTR, LPRASDIALPARAMSW, BOOL);
857 DWORD RasGetEntryDialParamsA(LPCSTR, LPRASDIALPARAMSA, LPBOOL);
858 DWORD RasGetEntryDialParamsW(LPCWSTR, LPRASDIALPARAMSW, LPBOOL);
859 DWORD RasEnumDevicesA(LPRASDEVINFOA, LPDWORD, LPDWORD);
860 DWORD RasEnumDevicesW(LPRASDEVINFOW, LPDWORD, LPDWORD);
861 DWORD RasGetCountryInfoA(LPRASCTRYINFOA, LPDWORD);
862 DWORD RasGetCountryInfoW(LPRASCTRYINFOW, LPDWORD);
863 DWORD RasGetEntryPropertiesA(LPCSTR, LPCSTR, LPRASENTRYA, LPDWORD, LPBYTE, LPDWORD);
864 DWORD RasGetEntryPropertiesW(LPCWSTR, LPCWSTR, LPRASENTRYW, LPDWORD, LPBYTE, LPDWORD);
865 DWORD RasSetEntryPropertiesA(LPCSTR, LPCSTR, LPRASENTRYA, DWORD, LPBYTE, DWORD);
866 DWORD RasSetEntryPropertiesW(LPCWSTR, LPCWSTR, LPRASENTRYW, DWORD, LPBYTE, DWORD);
867 DWORD RasRenameEntryA(LPCSTR, LPCSTR, LPCSTR);
868 DWORD RasRenameEntryW(LPCWSTR, LPCWSTR, LPCWSTR);
869 DWORD RasDeleteEntryA(LPCSTR, LPCSTR);
870 DWORD RasDeleteEntryW(LPCWSTR, LPCWSTR);
871 DWORD RasValidateEntryNameA(LPCSTR, LPCSTR);
872 DWORD RasValidateEntryNameW(LPCWSTR, LPCWSTR);
873
874 //static if (_WIN32_WINNT >= 0x401) {
875 alias BOOL function(LPSTR, LPSTR, LPRASADPARAMS, LPDWORD) RASADFUNCA;
876 alias BOOL function(LPWSTR, LPWSTR, LPRASADPARAMS, LPDWORD) RASADFUNCW;
877
878 DWORD RasGetSubEntryHandleA(HRASCONN, DWORD, LPHRASCONN);
879 DWORD RasGetSubEntryHandleW(HRASCONN, DWORD, LPHRASCONN);
880 DWORD RasGetCredentialsA(LPCSTR, LPCSTR, LPRASCREDENTIALSA);
881 DWORD RasGetCredentialsW(LPCWSTR, LPCWSTR, LPRASCREDENTIALSW);
882 DWORD RasSetCredentialsA(LPCSTR, LPCSTR, LPRASCREDENTIALSA, BOOL);
883 DWORD RasSetCredentialsW(LPCWSTR, LPCWSTR, LPRASCREDENTIALSW, BOOL);
884 DWORD RasConnectionNotificationA(HRASCONN, HANDLE, DWORD);
885 DWORD RasConnectionNotificationW(HRASCONN, HANDLE, DWORD);
886 DWORD RasGetSubEntryPropertiesA(LPCSTR, LPCSTR, DWORD, LPRASSUBENTRYA, LPDWORD, LPBYTE, LPDWORD);
887 DWORD RasGetSubEntryPropertiesW(LPCWSTR, LPCWSTR, DWORD, LPRASSUBENTRYW, LPDWORD, LPBYTE, LPDWORD);
888 DWORD RasSetSubEntryPropertiesA(LPCSTR, LPCSTR, DWORD, LPRASSUBENTRYA, DWORD, LPBYTE, DWORD);
889 DWORD RasSetSubEntryPropertiesW(LPCWSTR, LPCWSTR, DWORD, LPRASSUBENTRYW, DWORD, LPBYTE, DWORD);
890 DWORD RasGetAutodialAddressA(LPCSTR, LPDWORD, LPRASAUTODIALENTRYA, LPDWORD, LPDWORD);
891 DWORD RasGetAutodialAddressW(LPCWSTR, LPDWORD, LPRASAUTODIALENTRYW, LPDWORD, LPDWORD);
892 DWORD RasSetAutodialAddressA(LPCSTR, DWORD, LPRASAUTODIALENTRYA, DWORD, DWORD);
893 DWORD RasSetAutodialAddressW(LPCWSTR, DWORD, LPRASAUTODIALENTRYW, DWORD, DWORD);
894 DWORD RasEnumAutodialAddressesA(LPSTR*, LPDWORD, LPDWORD);
895 DWORD RasEnumAutodialAddressesW(LPWSTR*, LPDWORD, LPDWORD);
896 DWORD RasGetAutodialEnableA(DWORD, LPBOOL);
897 DWORD RasGetAutodialEnableW(DWORD, LPBOOL);
898 DWORD RasSetAutodialEnableA(DWORD, BOOL);
899 DWORD RasSetAutodialEnableW(DWORD, BOOL);
900 DWORD RasGetAutodialParamA(DWORD, LPVOID, LPDWORD);
901 DWORD RasGetAutodialParamW(DWORD, LPVOID, LPDWORD);
902 DWORD RasSetAutodialParamA(DWORD, LPVOID, DWORD);
903 DWORD RasSetAutodialParamW(DWORD, LPVOID, DWORD);
904 //}
905
906 static if (_WIN32_WINNT >= 0x500) {
907 alias DWORD function(HRASCONN) RasCustomHangUpFn;
908 alias DWORD function(LPCTSTR, LPCTSTR, DWORD) RasCustomDeleteEntryNotifyFn;
909 alias DWORD function(HINSTANCE, LPRASDIALEXTENSIONS, LPCTSTR, LPRASDIALPARAMS, DWORD, LPVOID,
910 LPHRASCONN, DWORD) RasCustomDialFn;
911
912 DWORD RasInvokeEapUI(HRASCONN, DWORD, LPRASDIALEXTENSIONS, HWND);
913 DWORD RasGetLinkStatistics(HRASCONN, DWORD, RAS_STATS*);
914 DWORD RasGetConnectionStatistics(HRASCONN, RAS_STATS*);
915 DWORD RasClearLinkStatistics(HRASCONN, DWORD);
916 DWORD RasClearConnectionStatistics(HRASCONN);
917 DWORD RasGetEapUserDataA(HANDLE, LPCSTR, LPCSTR, BYTE*, DWORD*);
918 DWORD RasGetEapUserDataW(HANDLE, LPCWSTR, LPCWSTR, BYTE*, DWORD*);
919 DWORD RasSetEapUserDataA(HANDLE, LPCSTR, LPCSTR, BYTE*, DWORD);
920 DWORD RasSetEapUserDataW(HANDLE, LPCWSTR, LPCWSTR, BYTE*, DWORD);
921 DWORD RasGetCustomAuthDataA(LPCSTR, LPCSTR, BYTE*, DWORD*);
922 DWORD RasGetCustomAuthDataW(LPCWSTR, LPCWSTR, BYTE*, DWORD*);
923 DWORD RasSetCustomAuthDataA(LPCSTR, LPCSTR, BYTE*, DWORD);
924 DWORD RasSetCustomAuthDataW(LPCWSTR, LPCWSTR, BYTE*, DWORD);
925 DWORD RasGetEapUserIdentityW(LPCWSTR, LPCWSTR, DWORD, HWND, LPRASEAPUSERIDENTITYW*);
926 DWORD RasGetEapUserIdentityA(LPCSTR, LPCSTR, DWORD, HWND, LPRASEAPUSERIDENTITYA*);
927 void RasFreeEapUserIdentityW(LPRASEAPUSERIDENTITYW);
928 void RasFreeEapUserIdentityA(LPRASEAPUSERIDENTITYA);
929 }
930 } // extern (Windows)
931
932
933 /* UNICODE defines for functions */
version(Unicode)934 version (Unicode) {
935 alias RasDialW RasDial;
936 alias RasEnumConnectionsW RasEnumConnections;
937 alias RasEnumEntriesW RasEnumEntries;
938 alias RasGetConnectStatusW RasGetConnectStatus;
939 alias RasGetErrorStringW RasGetErrorString;
940 alias RasHangUpW RasHangUp;
941 alias RasGetProjectionInfoW RasGetProjectionInfo;
942 alias RasCreatePhonebookEntryW RasCreatePhonebookEntry;
943 alias RasEditPhonebookEntryW RasEditPhonebookEntry;
944 alias RasSetEntryDialParamsW RasSetEntryDialParams;
945 alias RasGetEntryDialParamsW RasGetEntryDialParams;
946 alias RasEnumDevicesW RasEnumDevices;
947 alias RasGetCountryInfoW RasGetCountryInfo;
948 alias RasGetEntryPropertiesW RasGetEntryProperties;
949 alias RasSetEntryPropertiesW RasSetEntryProperties;
950 alias RasRenameEntryW RasRenameEntry;
951 alias RasDeleteEntryW RasDeleteEntry;
952 alias RasValidateEntryNameW RasValidateEntryName;
953
954 //static if (_WIN32_WINNT >= 0x401) {
955 alias RASADFUNCW RASADFUNC;
956 alias RasGetSubEntryHandleW RasGetSubEntryHandle;
957 alias RasConnectionNotificationW RasConnectionNotification;
958 alias RasGetSubEntryPropertiesW RasGetSubEntryProperties;
959 alias RasSetSubEntryPropertiesW RasSetSubEntryProperties;
960 alias RasGetCredentialsW RasGetCredentials;
961 alias RasSetCredentialsW RasSetCredentials;
962 alias RasGetAutodialAddressW RasGetAutodialAddress;
963 alias RasSetAutodialAddressW RasSetAutodialAddress;
964 alias RasEnumAutodialAddressesW RasEnumAutodialAddresses;
965 alias RasGetAutodialEnableW RasGetAutodialEnable;
966 alias RasSetAutodialEnableW RasSetAutodialEnable;
967 alias RasGetAutodialParamW RasGetAutodialParam;
968 alias RasSetAutodialParamW RasSetAutodialParam;
969 //}
970
971 //static if (_WIN32_WINNT >= 0x500) {
972 alias RasGetEapUserDataW RasGetEapUserData;
973 alias RasSetEapUserDataW RasSetEapUserData;
974 alias RasGetCustomAuthDataW RasGetCustomAuthData;
975 alias RasSetCustomAuthDataW RasSetCustomAuthData;
976 alias RasGetEapUserIdentityW RasGetEapUserIdentity;
977 alias RasFreeEapUserIdentityW RasFreeEapUserIdentity;
978 //}
979
980 } else { // !Unicode
981 alias RasDialA RasDial;
982 alias RasEnumConnectionsA RasEnumConnections;
983 alias RasEnumEntriesA RasEnumEntries;
984 alias RasGetConnectStatusA RasGetConnectStatus;
985 alias RasGetErrorStringA RasGetErrorString;
986 alias RasHangUpA RasHangUp;
987 alias RasGetProjectionInfoA RasGetProjectionInfo;
988 alias RasCreatePhonebookEntryA RasCreatePhonebookEntry;
989 alias RasEditPhonebookEntryA RasEditPhonebookEntry;
990 alias RasSetEntryDialParamsA RasSetEntryDialParams;
991 alias RasGetEntryDialParamsA RasGetEntryDialParams;
992 alias RasEnumDevicesA RasEnumDevices;
993 alias RasGetCountryInfoA RasGetCountryInfo;
994 alias RasGetEntryPropertiesA RasGetEntryProperties;
995 alias RasSetEntryPropertiesA RasSetEntryProperties;
996 alias RasRenameEntryA RasRenameEntry;
997 alias RasDeleteEntryA RasDeleteEntry;
998 alias RasValidateEntryNameA RasValidateEntryName;
999
1000 //static if (_WIN32_WINNT >= 0x401) {
1001 alias RASADFUNCA RASADFUNC;
1002 alias RasGetSubEntryHandleA RasGetSubEntryHandle;
1003 alias RasConnectionNotificationA RasConnectionNotification;
1004 alias RasGetSubEntryPropertiesA RasGetSubEntryProperties;
1005 alias RasSetSubEntryPropertiesA RasSetSubEntryProperties;
1006 alias RasGetCredentialsA RasGetCredentials;
1007 alias RasSetCredentialsA RasSetCredentials;
1008 alias RasGetAutodialAddressA RasGetAutodialAddress;
1009 alias RasSetAutodialAddressA RasSetAutodialAddress;
1010 alias RasEnumAutodialAddressesA RasEnumAutodialAddresses;
1011 alias RasGetAutodialEnableA RasGetAutodialEnable;
1012 alias RasSetAutodialEnableA RasSetAutodialEnable;
1013 alias RasGetAutodialParamA RasGetAutodialParam;
1014 alias RasSetAutodialParamA RasSetAutodialParam;
1015 //}
1016
1017 //static if (_WIN32_WINNT >= 0x500) {
1018 alias RasGetEapUserDataA RasGetEapUserData;
1019 alias RasSetEapUserDataA RasSetEapUserData;
1020 alias RasGetCustomAuthDataA RasGetCustomAuthData;
1021 alias RasSetCustomAuthDataA RasSetCustomAuthData;
1022 alias RasGetEapUserIdentityA RasGetEapUserIdentity;
1023 alias RasFreeEapUserIdentityA RasFreeEapUserIdentity;
1024 //}
1025 } //#endif // !Unicode
1026