core.sys.windows.ras source code

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 core/sys/windows/_ras.d)
8  */
9 module core.sys.windows.ras;
10 version (Windows):
11 
12 version (ANSI) {} else version = Unicode;
13 pragma(lib, "rasapi32");
14 
15 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 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*/
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 */
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
The OpenD Programming Language
