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