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