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