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