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