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