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