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 nulib.system.win32.ras; 10 11 12 version (ANSI) {} else version = Unicode; 13 pragma(lib, "rasapi32"); 14 15 import nulib.system.win32.basetyps, nulib.system.win32.lmcons, nulib.system.win32.w32api, nulib.system.win32.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 LPRASCONNSTATE = RASCONNSTATE*; 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 LPRASPROJECTION = RASPROJECTION*; 225 226 alias HRASCONN = HANDLE; 227 alias LPHRASCONN = HRASCONN*; 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 LPRASCONNW = RASCONNW*; 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 LPRASCONNA = RASCONNA*; 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 LPRASCONNSTATUSW = RASCONNSTATUSW*; 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 LPRASCONNSTATUSA = RASCONNSTATUSA*; 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 LPRASDIALPARAMSW = RASDIALPARAMSW*; 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 LPRASDIALPARAMSA = RASDIALPARAMSA*; 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 LPRASDIALEXTENSIONS = RASDIALEXTENSIONS*; 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 LPRASENTRYNAMEW = RASENTRYNAMEW*; 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 LPRASENTRYNAMEA = RASENTRYNAMEA*; 375 376 struct RASAMBW{ 377 DWORD dwSize; 378 DWORD dwError; 379 WCHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0; 380 BYTE bLana; 381 } 382 alias LPRASAMBW = RASAMBW*; 383 384 struct RASAMBA{ 385 DWORD dwSize; 386 DWORD dwError; 387 CHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0; 388 BYTE bLana; 389 } 390 alias LPRASAMBA = RASAMBA*; 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 LPRASPPPNBFW = RASPPPNBFW*; 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 LPRASPPPNBFA = RASPPPNBFA*; 411 412 struct RASPPPIPXW { 413 DWORD dwSize; 414 DWORD dwError; 415 WCHAR[RAS_MaxIpxAddress + 1] szIpxAddress = 0; 416 } 417 alias LPRASPPPIPXW = RASPPPIPXW*; 418 419 struct RASPPPIPXA { 420 DWORD dwSize; 421 DWORD dwError; 422 CHAR[RAS_MaxIpxAddress + 1] szIpxAddress = 0; 423 } 424 alias LPRASPPPIPXA = RASPPPIPXA*; 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 LPRASPPPIPW = RASPPPIPW*; 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 LPRASPPPIPA = RASPPPIPA*; 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 LPRASPPPLCPW = RASPPPLCPW*; 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 LPRASPPPLCPA = RASPPPLCPA*; 495 496 struct RASSLIPW{ 497 DWORD dwSize; 498 DWORD dwError; 499 WCHAR[RAS_MaxIpAddress + 1] szIpAddress = 0; 500 } 501 alias LPRASSLIPW = RASSLIPW*; 502 503 struct RASSLIPA{ 504 DWORD dwSize; 505 DWORD dwError; 506 CHAR[RAS_MaxIpAddress + 1] szIpAddress = 0; 507 } 508 alias LPRASSLIPA = RASSLIPA*; 509 510 struct RASDEVINFOW{ 511 DWORD dwSize; 512 WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0; 513 WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0; 514 } 515 alias LPRASDEVINFOW = RASDEVINFOW*; 516 517 struct RASDEVINFOA{ 518 DWORD dwSize; 519 CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0; 520 CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0; 521 } 522 alias LPRASDEVINFOA = RASDEVINFOA*; 523 524 struct RASCTRYINFO { 525 DWORD dwSize; 526 DWORD dwCountryID; 527 DWORD dwNextCountryID; 528 DWORD dwCountryCode; 529 DWORD dwCountryNameOffset; 530 } 531 alias LPRASCTRYINFO = RASCTRYINFO*; 532 alias RASCTRYINFO RASCTRYINFOW, RASCTRYINFOA; 533 alias LPRASCTRYINFOW = RASCTRYINFOW*; 534 alias LPRASCTRYINFOA = RASCTRYINFOA*; 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 LPRASENTRYW = RASENTRYW*; 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 LPRASENTRYA = RASENTRYA*; 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 LPRASADPARAMS = RASADPARAMS*; 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 LPRASSUBENTRYW = RASSUBENTRYW*; 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 LPRASSUBENTRYA = RASSUBENTRYA*; 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 LPRASCREDENTIALSW = RASCREDENTIALSW*; 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 LPRASCREDENTIALSA = RASCREDENTIALSA*; 688 689 struct RASAUTODIALENTRYW{ 690 DWORD dwSize; 691 DWORD dwFlags; 692 DWORD dwDialingLocation; 693 WCHAR[RAS_MaxEntryName + 1] szEntry = 0; 694 } 695 alias LPRASAUTODIALENTRYW = RASAUTODIALENTRYW*; 696 697 struct RASAUTODIALENTRYA{ 698 DWORD dwSize; 699 DWORD dwFlags; 700 DWORD dwDialingLocation; 701 CHAR[RAS_MaxEntryName + 1] szEntry = 0; 702 } 703 alias LPRASAUTODIALENTRYA = RASAUTODIALENTRYA*; 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 LPRASPPPCCP = RASPPPCCP*; 716 717 struct RASEAPUSERIDENTITYW{ 718 WCHAR[UNLEN + 1] szUserName = 0; 719 DWORD dwSizeofEapInfo; 720 BYTE[1] pbEapInfo; 721 } 722 alias LPRASEAPUSERIDENTITYW = RASEAPUSERIDENTITYW*; 723 724 struct RASEAPUSERIDENTITYA{ 725 CHAR[UNLEN + 1] szUserName = 0; 726 DWORD dwSizeofEapInfo; 727 BYTE[1] pbEapInfo; 728 } 729 alias LPRASEAPUSERIDENTITYA = RASEAPUSERIDENTITYA*; 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 PRAS_STATS = RAS_STATS*; 749 //} 750 751 752 /* UNICODE typedefs for structures*/ 753 version (Unicode) { 754 alias RASCONN = RASCONNW; 755 alias RASENTRY = RASENTRYW; 756 alias RASCONNSTATUS = RASCONNSTATUSW; 757 alias RASDIALPARAMS = RASDIALPARAMSW; 758 alias RASAMB = RASAMBW; 759 alias RASPPPNBF = RASPPPNBFW; 760 alias RASPPPIPX = RASPPPIPXW; 761 alias RASPPPIP = RASPPPIPW; 762 alias RASPPPLCP = RASPPPLCPW; 763 alias RASSLIP = RASSLIPW; 764 alias RASDEVINFO = RASDEVINFOW; 765 alias RASENTRYNAME = RASENTRYNAMEW; 766 767 //static if (_WIN32_WINNT >= 0x401) { 768 alias RASSUBENTRY = RASSUBENTRYW; 769 alias RASCREDENTIALS = RASCREDENTIALSW; 770 alias RASAUTODIALENTRY = RASAUTODIALENTRYW; 771 //} 772 773 //static if (_WIN32_WINNT >= 0x500) { 774 alias RASEAPUSERIDENTITY = RASEAPUSERIDENTITYW; 775 //} 776 777 } else { // ! defined UNICODE 778 779 alias RASCONN = RASCONNA; 780 alias RASENTRYA RASENTRY; 781 alias RASCONNSTATUS = RASCONNSTATUSA; 782 alias RASDIALPARAMS = RASDIALPARAMSA; 783 alias RASAMB = RASAMBA; 784 alias RASPPPNBF = RASPPPNBFA; 785 alias RASPPPIPX = RASPPPIPXA; 786 alias RASPPPIP = RASPPPIPA; 787 alias RASPPPLCP = RASPPPLCPA; 788 alias RASSLIP = RASSLIPA; 789 alias RASDEVINFOA RASDEVINFO; 790 alias RASENTRYNAME = RASENTRYNAMEA; 791 792 //static if (_WIN32_WINNT >= 0x401) { 793 alias RASSUBENTRY = RASSUBENTRYA; 794 alias RASCREDENTIALS = RASCREDENTIALSA; 795 alias RASAUTODIALENTRY = RASAUTODIALENTRYA; 796 //} 797 //static if (_WIN32_WINNT >= 0x500) { 798 alias RASEAPUSERIDENTITY = RASEAPUSERIDENTITYA; 799 //} 800 }// ! UNICODE 801 802 803 alias LPRASCONN = RASCONN*; 804 alias LPRASENTRY = RASENTRY*; 805 alias LPRASCONNSTATUS = RASCONNSTATUS*; 806 alias LPRASDIALPARAMS = RASDIALPARAMS*; 807 alias LPRASAM = RASAMB*; 808 alias LPRASPPPNBF = RASPPPNBF*; 809 alias LPRASPPPIPX = RASPPPIPX*; 810 alias LPRASPPPIP = RASPPPIP*; 811 alias LPRASPPPLCP = RASPPPLCP*; 812 alias LPRASSLIP = RASSLIP*; 813 alias LPRASDEVINFO = RASDEVINFO*; 814 alias LPRASENTRYNAME = RASENTRYNAME*; 815 816 //static if (_WIN32_WINNT >= 0x401) { 817 alias LPRASSUBENTRY = RASSUBENTRY*; 818 alias LPRASCREDENTIALS = RASCREDENTIALS*; 819 alias LPRASAUTODIALENTRY = RASAUTODIALENTRY*; 820 //} 821 //static if (_WIN32_WINNT >= 0x500) { 822 alias LPRASEAPUSERIDENTITY = RASEAPUSERIDENTITY*; 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 RasDial = RasDialW; 936 alias RasEnumConnections = RasEnumConnectionsW; 937 alias RasEnumEntries = RasEnumEntriesW; 938 alias RasGetConnectStatus = RasGetConnectStatusW; 939 alias RasGetErrorString = RasGetErrorStringW; 940 alias RasHangUp = RasHangUpW; 941 alias RasGetProjectionInfo = RasGetProjectionInfoW; 942 alias RasCreatePhonebookEntry = RasCreatePhonebookEntryW; 943 alias RasEditPhonebookEntry = RasEditPhonebookEntryW; 944 alias RasSetEntryDialParams = RasSetEntryDialParamsW; 945 alias RasGetEntryDialParams = RasGetEntryDialParamsW; 946 alias RasEnumDevices = RasEnumDevicesW; 947 alias RasGetCountryInfo = RasGetCountryInfoW; 948 alias RasGetEntryProperties = RasGetEntryPropertiesW; 949 alias RasSetEntryProperties = RasSetEntryPropertiesW; 950 alias RasRenameEntry = RasRenameEntryW; 951 alias RasDeleteEntry = RasDeleteEntryW; 952 alias RasValidateEntryName = RasValidateEntryNameW; 953 954 //static if (_WIN32_WINNT >= 0x401) { 955 alias RASADFUNC = RASADFUNCW; 956 alias RasGetSubEntryHandle = RasGetSubEntryHandleW; 957 alias RasConnectionNotification = RasConnectionNotificationW; 958 alias RasGetSubEntryProperties = RasGetSubEntryPropertiesW; 959 alias RasSetSubEntryProperties = RasSetSubEntryPropertiesW; 960 alias RasGetCredentials = RasGetCredentialsW; 961 alias RasSetCredentials = RasSetCredentialsW; 962 alias RasGetAutodialAddress = RasGetAutodialAddressW; 963 alias RasSetAutodialAddress = RasSetAutodialAddressW; 964 alias RasEnumAutodialAddresses = RasEnumAutodialAddressesW; 965 alias RasGetAutodialEnable = RasGetAutodialEnableW; 966 alias RasSetAutodialEnable = RasSetAutodialEnableW; 967 alias RasGetAutodialParam = RasGetAutodialParamW; 968 alias RasSetAutodialParam = RasSetAutodialParamW; 969 //} 970 971 //static if (_WIN32_WINNT >= 0x500) { 972 alias RasGetEapUserData = RasGetEapUserDataW; 973 alias RasSetEapUserData = RasSetEapUserDataW; 974 alias RasGetCustomAuthData = RasGetCustomAuthDataW; 975 alias RasSetCustomAuthData = RasSetCustomAuthDataW; 976 alias RasGetEapUserIdentity = RasGetEapUserIdentityW; 977 alias RasFreeEapUserIdentity = RasFreeEapUserIdentityW; 978 //} 979 980 } else { // !Unicode 981 alias RasDial = RasDialA; 982 alias RasEnumConnections = RasEnumConnectionsA; 983 alias RasEnumEntries = RasEnumEntriesA; 984 alias RasGetConnectStatus = RasGetConnectStatusA; 985 alias RasGetErrorString = RasGetErrorStringA; 986 alias RasHangUp = RasHangUpA; 987 alias RasGetProjectionInfo = RasGetProjectionInfoA; 988 alias RasCreatePhonebookEntry = RasCreatePhonebookEntryA; 989 alias RasEditPhonebookEntry = RasEditPhonebookEntryA; 990 alias RasSetEntryDialParams = RasSetEntryDialParamsA; 991 alias RasGetEntryDialParams = RasGetEntryDialParamsA; 992 alias RasEnumDevices = RasEnumDevicesA; 993 alias RasGetCountryInfo = RasGetCountryInfoA; 994 alias RasGetEntryProperties = RasGetEntryPropertiesA; 995 alias RasSetEntryProperties = RasSetEntryPropertiesA; 996 alias RasRenameEntry = RasRenameEntryA; 997 alias RasDeleteEntry = RasDeleteEntryA; 998 alias RasValidateEntryName = RasValidateEntryNameA; 999 1000 //static if (_WIN32_WINNT >= 0x401) { 1001 alias RASADFUNC = RASADFUNCA; 1002 alias RasGetSubEntryHandle = RasGetSubEntryHandleA; 1003 alias RasConnectionNotification = RasConnectionNotificationA; 1004 alias RasGetSubEntryProperties = RasGetSubEntryPropertiesA; 1005 alias RasSetSubEntryProperties = RasSetSubEntryPropertiesA; 1006 alias RasGetCredentials = RasGetCredentialsA; 1007 alias RasSetCredentials = RasSetCredentialsA; 1008 alias RasGetAutodialAddress = RasGetAutodialAddressA; 1009 alias RasSetAutodialAddress = RasSetAutodialAddressA; 1010 alias RasEnumAutodialAddresses = RasEnumAutodialAddressesA; 1011 alias RasGetAutodialEnable = RasGetAutodialEnableA; 1012 alias RasSetAutodialEnable = RasSetAutodialEnableA; 1013 alias RasGetAutodialParam = RasGetAutodialParamA; 1014 alias RasSetAutodialParam = RasSetAutodialParamA; 1015 //} 1016 1017 //static if (_WIN32_WINNT >= 0x500) { 1018 alias RasGetEapUserData = RasGetEapUserDataA; 1019 alias RasSetEapUserData = RasSetEapUserDataA; 1020 alias RasGetCustomAuthData = RasGetCustomAuthDataA; 1021 alias RasSetCustomAuthData = RasSetCustomAuthDataA; 1022 alias RasGetEapUserIdentity = RasGetEapUserIdentityA; 1023 alias RasFreeEapUserIdentity = RasFreeEapUserIdentityA; 1024 //} 1025 } //#endif // !Unicode