Mercurial > projects > ddbg_continued
diff win32/ras.d @ 1:4a9dcbd9e54f
-files of 0.13 beta
-fixes so that it now compiles with the current dmd version
| author | marton@basel.hu |
|---|---|
| date | Tue, 05 Apr 2011 20:44:01 +0200 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/win32/ras.d Tue Apr 05 20:44:01 2011 +0200 @@ -0,0 +1,1029 @@ +/***********************************************************************\ +* ras.d * +* * +* Windows API header module * +* * +* Translated from MinGW Windows headers * +* * +* Placed into public domain * +\***********************************************************************/ +module win32.ras; +pragma(lib, "rasapi32.lib"); + +private import win32.basetyps, win32.lmcons, win32.w32api, win32.windef; + +align(4): + +const RAS_MaxDeviceType = 16; +const RAS_MaxPhoneNumber = 128; +const RAS_MaxIpAddress = 15; +const RAS_MaxIpxAddress = 21; +const RAS_MaxEntryName = 256; +const RAS_MaxDeviceName = 128; +const RAS_MaxCallbackNumber = RAS_MaxPhoneNumber; +const RAS_MaxAreaCode = 10; +const RAS_MaxPadType = 32; +const RAS_MaxX25Address = 200; +const RAS_MaxFacilities = 200; +const RAS_MaxUserData = 200; +const RAS_MaxReplyMessage = 1024; + +const RDEOPT_UsePrefixSuffix = 0x00000001; +const RDEOPT_PausedStates = 0x00000002; +const RDEOPT_IgnoreModemSpeaker = 0x00000004; +const RDEOPT_SetModemSpeaker = 0x00000008; +const RDEOPT_IgnoreSoftwareCompression = 0x00000010; +const RDEOPT_SetSoftwareCompression = 0x00000020; +const RDEOPT_DisableConnectedUI = 0x00000040; +const RDEOPT_DisableReconnectUI = 0x00000080; +const RDEOPT_DisableReconnect = 0x00000100; +const RDEOPT_NoUser = 0x00000200; +const RDEOPT_PauseOnScript = 0x00000400; +const RDEOPT_Router = 0x00000800; + +const REN_User = 0x00000000; +const REN_AllUsers = 0x00000001; +const VS_Default = 0; +const VS_PptpOnly = 1; +const VS_PptpFirst = 2; +const VS_L2tpOnly = 3; +const VS_L2tpFirst = 4; + +const RASDIALEVENT = "RasDialEvent"; +const WM_RASDIALEVENT = 0xCCCD; + +const RASEO_UseCountryAndAreaCodes = 0x00000001; +const RASEO_SpecificIpAddr = 0x00000002; +const RASEO_SpecificNameServers = 0x00000004; +const RASEO_IpHeaderCompression = 0x00000008; +const RASEO_RemoteDefaultGateway = 0x00000010; +const RASEO_DisableLcpExtensions = 0x00000020; +const RASEO_TerminalBeforeDial = 0x00000040; +const RASEO_TerminalAfterDial = 0x00000080; +const RASEO_ModemLights = 0x00000100; +const RASEO_SwCompression = 0x00000200; +const RASEO_RequireEncryptedPw = 0x00000400; +const RASEO_RequireMsEncryptedPw = 0x00000800; +const RASEO_RequireDataEncryption = 0x00001000; +const RASEO_NetworkLogon = 0x00002000; +const RASEO_UseLogonCredentials = 0x00004000; +const RASEO_PromoteAlternates = 0x00008000; +const RASNP_NetBEUI = 0x00000001; +const RASNP_Ipx = 0x00000002; +const RASNP_Ip = 0x00000004; +const RASFP_Ppp = 0x00000001; +const RASFP_Slip = 0x00000002; +const RASFP_Ras = 0x00000004; + +const TCHAR[] + RASDT_Modem = "modem", + RASDT_Isdn = "isdn", + RASDT_X25 = "x25", + RASDT_Vpn = "vpn", + RASDT_Pad = "pad", + RASDT_Generic = "GENERIC", + RASDT_Serial = "SERIAL", + RASDT_FrameRelay = "FRAMERELAY", + RASDT_Atm = "ATM", + RASDT_Sonet = "SONET", + RASDT_SW56 = "SW56", + RASDT_Irda = "IRDA", + RASDT_Parallel = "PARALLEL"; + +const RASET_Phone = 1; +const RASET_Vpn = 2; +const RASET_Direct = 3; +const RASET_Internet = 4; + +static if (WINVER >= 0x0401) { + const RASEO_SecureLocalFiles = 0x00010000; + const RASCN_Connection = 0x00000001; + const RASCN_Disconnection = 0x00000002; + const RASCN_BandwidthAdded = 0x00000004; + const RASCN_BandwidthRemoved = 0x00000008; + const RASEDM_DialAll = 1; + const RASEDM_DialAsNeeded = 2; + const RASIDS_Disabled = 0xffffffff; + const RASIDS_UseGlobalValue = 0; + const RASADFLG_PositionDlg = 0x00000001; + const RASCM_UserName = 0x00000001; + const RASCM_Password = 0x00000002; + const RASCM_Domain = 0x00000004; + const RASADP_DisableConnectionQuery = 0; + const RASADP_LoginSessionDisable = 1; + const RASADP_SavedAddressesLimit = 2; + const RASADP_FailedConnectionTimeout = 3; + const RASADP_ConnectionQueryTimeout = 4; +} +static if (WINVER >= 0x0500) { + const RDEOPT_CustomDial = 0x00001000; + const RASLCPAP_PAP = 0xC023; + const RASLCPAP_SPAP = 0xC027; + const RASLCPAP_CHAP = 0xC223; + const RASLCPAP_EAP = 0xC227; + const RASLCPAD_CHAP_MD5 = 0x05; + const RASLCPAD_CHAP_MS = 0x80; + const RASLCPAD_CHAP_MSV2 = 0x81; + const RASLCPO_PFC = 0x00000001; + const RASLCPO_ACFC = 0x00000002; + const RASLCPO_SSHF = 0x00000004; + const RASLCPO_DES_56 = 0x00000008; + const RASLCPO_3_DES = 0x00000010; + + const RASCCPCA_MPPC = 0x00000006; + const RASCCPCA_STAC = 0x00000005; + + const RASCCPO_Compression = 0x00000001; + const RASCCPO_HistoryLess = 0x00000002; + const RASCCPO_Encryption56bit = 0x00000010; + const RASCCPO_Encryption40bit = 0x00000020; + const RASCCPO_Encryption128bit = 0x00000040; + + const RASEO_RequireEAP = 0x00020000; + const RASEO_RequirePAP = 0x00040000; + const RASEO_RequireSPAP = 0x00080000; + const RASEO_Custom = 0x00100000; + const RASEO_PreviewPhoneNumber = 0x00200000; + const RASEO_SharedPhoneNumbers = 0x00800000; + const RASEO_PreviewUserPw = 0x01000000; + const RASEO_PreviewDomain = 0x02000000; + const RASEO_ShowDialingProgress = 0x04000000; + const RASEO_RequireCHAP = 0x08000000; + const RASEO_RequireMsCHAP = 0x10000000; + const RASEO_RequireMsCHAP2 = 0x20000000; + const RASEO_RequireW95MSCHAP = 0x40000000; + const RASEO_CustomScript = 0x80000000; + + const RASIPO_VJ = 0x00000001; + const RCD_SingleUser = 0; + const RCD_AllUsers = 0x00000001; + const RCD_Eap = 0x00000002; + const RASEAPF_NonInteractive = 0x00000002; + const RASEAPF_Logon = 0x00000004; + const RASEAPF_Preview = 0x00000008; + const ET_40Bit = 1; + const ET_128Bit = 2; + const ET_None = 0; + const ET_Require = 1; + const ET_RequireMax = 2; + const ET_Optional = 3; +} + +const RASCS_PAUSED = 0x1000; +const RASCS_DONE = 0x2000; +enum RASCONNSTATE { + RASCS_OpenPort = 0, + RASCS_PortOpened, + RASCS_ConnectDevice, + RASCS_DeviceConnected, + RASCS_AllDevicesConnected, + RASCS_Authenticate, + RASCS_AuthNotify, + RASCS_AuthRetry, + RASCS_AuthCallback, + RASCS_AuthChangePassword, + RASCS_AuthProject, + RASCS_AuthLinkSpeed, + RASCS_AuthAck, + RASCS_ReAuthenticate, + RASCS_Authenticated, + RASCS_PrepareForCallback, + RASCS_WaitForModemReset, + RASCS_WaitForCallback, + RASCS_Projected, + RASCS_StartAuthentication, + RASCS_CallbackComplete, + RASCS_LogonNetwork, + RASCS_SubEntryConnected, + RASCS_SubEntryDisconnected, + RASCS_Interactive = RASCS_PAUSED, + RASCS_RetryAuthentication, + RASCS_CallbackSetByCaller, + RASCS_PasswordExpired, +// static if (WINVER >= 0x0500) { + RASCS_InvokeEapUI, +// } + RASCS_Connected = RASCS_DONE, + RASCS_Disconnected +} +alias RASCONNSTATE* LPRASCONNSTATE; + +enum RASPROJECTION { + RASP_Amb = 0x10000, + RASP_PppNbf = 0x803F, + RASP_PppIpx = 0x802B, + RASP_PppIp = 0x8021, +// static if (WINVER >= 0x0500) { + RASP_PppCcp = 0x80FD, +// } + RASP_PppLcp = 0xC021, + RASP_Slip = 0x20000 +} +alias RASPROJECTION* LPRASPROJECTION; + +typedef HANDLE HRASCONN; +alias HRASCONN* LPHRASCONN; + +struct RASCONNW { + DWORD dwSize; + HRASCONN hrasconn; + WCHAR szEntryName[RAS_MaxEntryName + 1]; + static if (WINVER >= 0x0400) { + WCHAR szDeviceType[RAS_MaxDeviceType + 1]; + WCHAR szDeviceName[RAS_MaxDeviceName + 1]; + } + static if (WINVER >= 0x0401) { + WCHAR szPhonebook[MAX_PATH]; + DWORD dwSubEntry; + } + static if (WINVER >= 0x0500) { + GUID guidEntry; + } + static if (WINVER >= 0x0501) { + DWORD dwFlags; + LUID luid; + } +} +alias RASCONNW* LPRASCONNW; + +struct RASCONNA { + DWORD dwSize; + HRASCONN hrasconn; + CHAR szEntryName[RAS_MaxEntryName + 1]; + static if (WINVER >= 0x0400) { + CHAR szDeviceType[RAS_MaxDeviceType + 1]; + CHAR szDeviceName[RAS_MaxDeviceName + 1]; + } + static if (WINVER >= 0x0401) { + CHAR szPhonebook[MAX_PATH]; + DWORD dwSubEntry; + } + static if (WINVER >= 0x0500) { + GUID guidEntry; + } + static if (WINVER >= 0x0501) { + DWORD dwFlags; + LUID luid; + } +} +alias RASCONNA* LPRASCONNA; + +struct RASCONNSTATUSW { + DWORD dwSize; + RASCONNSTATE rasconnstate; + DWORD dwError; + WCHAR szDeviceType[RAS_MaxDeviceType + 1]; + WCHAR szDeviceName[RAS_MaxDeviceName + 1]; + static if (WINVER >= 0x0401) { + WCHAR szPhoneNumber[RAS_MaxPhoneNumber + 1]; + } +} +alias RASCONNSTATUSW* LPRASCONNSTATUSW; + +struct RASCONNSTATUSA { + DWORD dwSize; + RASCONNSTATE rasconnstate; + DWORD dwError; + CHAR szDeviceType[RAS_MaxDeviceType + 1]; + CHAR szDeviceName[RAS_MaxDeviceName + 1]; + static if (WINVER >= 0x0401) { + CHAR szPhoneNumber[RAS_MaxPhoneNumber + 1]; + } +} +alias RASCONNSTATUSA* LPRASCONNSTATUSA; + +struct RASDIALPARAMSW { + DWORD dwSize; + WCHAR szEntryName[RAS_MaxEntryName + 1]; + WCHAR szPhoneNumber[RAS_MaxPhoneNumber + 1]; + WCHAR szCallbackNumber[RAS_MaxCallbackNumber + 1]; + WCHAR szUserName[UNLEN + 1]; + WCHAR szPassword[PWLEN + 1]; + WCHAR szDomain[DNLEN + 1]; + static if (WINVER >= 0x0401) { + DWORD dwSubEntry; + ULONG_PTR dwCallbackId; + } +} +alias RASDIALPARAMSW* LPRASDIALPARAMSW; + +struct RASDIALPARAMSA{ + DWORD dwSize; + CHAR szEntryName[RAS_MaxEntryName + 1]; + CHAR szPhoneNumber[RAS_MaxPhoneNumber + 1]; + CHAR szCallbackNumber[RAS_MaxCallbackNumber + 1]; + CHAR szUserName[UNLEN + 1]; + CHAR szPassword[PWLEN + 1]; + CHAR szDomain[DNLEN + 1]; + static if (WINVER >= 0x0401) { + DWORD dwSubEntry; + ULONG_PTR dwCallbackId; + } +} +alias RASDIALPARAMSA* LPRASDIALPARAMSA; + +static if (WINVER >= 0x0500) { + struct RASEAPINFO { + DWORD dwSizeofEapInfo; + BYTE *pbEapInfo; + } +} + +struct RASDIALEXTENSIONS { + DWORD dwSize; + DWORD dwfOptions; + HWND hwndParent; + ULONG_PTR reserved; + static if (WINVER >= 0x0500) { + ULONG_PTR reserved1; + RASEAPINFO RasEapInfo; + } +} +alias RASDIALEXTENSIONS* LPRASDIALEXTENSIONS; + +struct RASENTRYNAMEW { + DWORD dwSize; + WCHAR szEntryName[RAS_MaxEntryName + 1]; + static if (WINVER >= 0x0500) { + DWORD dwFlags; + WCHAR szPhonebookPath[MAX_PATH + 1]; + } +} +alias RASENTRYNAMEW* LPRASENTRYNAMEW; + +struct RASENTRYNAMEA{ + DWORD dwSize; + CHAR szEntryName[RAS_MaxEntryName + 1]; + static if (WINVER >= 0x0500) { + DWORD dwFlags; + CHAR szPhonebookPath[MAX_PATH + 1]; + } +} +alias RASENTRYNAMEA* LPRASENTRYNAMEA; + +struct RASAMBW{ + DWORD dwSize; + DWORD dwError; + WCHAR szNetBiosError[NETBIOS_NAME_LEN + 1]; + BYTE bLana; +} +alias RASAMBW* LPRASAMBW; + +struct RASAMBA{ + DWORD dwSize; + DWORD dwError; + CHAR szNetBiosError[NETBIOS_NAME_LEN + 1]; + BYTE bLana; +} +alias RASAMBA* LPRASAMBA; + +struct RASPPPNBFW{ + DWORD dwSize; + DWORD dwError; + DWORD dwNetBiosError; + WCHAR szNetBiosError[NETBIOS_NAME_LEN + 1]; + WCHAR szWorkstationName[NETBIOS_NAME_LEN + 1]; + BYTE bLana; +} +alias RASPPPNBFW* LPRASPPPNBFW; + +struct RASPPPNBFA{ + DWORD dwSize; + DWORD dwError; + DWORD dwNetBiosError; + CHAR szNetBiosError[NETBIOS_NAME_LEN + 1]; + CHAR szWorkstationName[NETBIOS_NAME_LEN + 1]; + BYTE bLana; +} +alias RASPPPNBFA* LPRASPPPNBFA; + +struct RASPPPIPXW { + DWORD dwSize; + DWORD dwError; + WCHAR szIpxAddress[RAS_MaxIpxAddress + 1]; +} +alias RASPPPIPXW* LPRASPPPIPXW; + +struct RASPPPIPXA { + DWORD dwSize; + DWORD dwError; + CHAR szIpxAddress[RAS_MaxIpxAddress + 1]; +} +alias RASPPPIPXA* LPRASPPPIPXA; + +struct RASPPPIPW{ + DWORD dwSize; + DWORD dwError; + WCHAR szIpAddress[RAS_MaxIpAddress + 1]; + //#ifndef WINNT35COMPATIBLE + WCHAR szServerIpAddress[RAS_MaxIpAddress + 1]; + //#endif + static if (WINVER >= 0x0500) { + DWORD dwOptions; + DWORD dwServerOptions; + } +} +alias RASPPPIPW* LPRASPPPIPW; + +struct RASPPPIPA{ + DWORD dwSize; + DWORD dwError; + CHAR szIpAddress[RAS_MaxIpAddress + 1]; + //#ifndef WINNT35COMPATIBLE + CHAR szServerIpAddress[RAS_MaxIpAddress + 1]; + //#endif + static if (WINVER >= 0x0500) { + DWORD dwOptions; + DWORD dwServerOptions; + } +} +alias RASPPPIPA* LPRASPPPIPA; + +struct RASPPPLCPW{ + DWORD dwSize; + BOOL fBundled; + static if (WINVER >= 0x0500) { + DWORD dwError; + DWORD dwAuthenticationProtocol; + DWORD dwAuthenticationData; + DWORD dwEapTypeId; + DWORD dwServerAuthenticationProtocol; + DWORD dwServerAuthenticationData; + DWORD dwServerEapTypeId; + BOOL fMultilink; + DWORD dwTerminateReason; + DWORD dwServerTerminateReason; + WCHAR szReplyMessage[RAS_MaxReplyMessage]; + DWORD dwOptions; + DWORD dwServerOptions; + } +} +alias RASPPPLCPW* LPRASPPPLCPW; + +struct RASPPPLCPA{ + DWORD dwSize; + BOOL fBundled; + static if (WINVER >= 0x0500) { + DWORD dwError; + DWORD dwAuthenticationProtocol; + DWORD dwAuthenticationData; + DWORD dwEapTypeId; + DWORD dwServerAuthenticationProtocol; + DWORD dwServerAuthenticationData; + DWORD dwServerEapTypeId; + BOOL fMultilink; + DWORD dwTerminateReason; + DWORD dwServerTerminateReason; + CHAR szReplyMessage[RAS_MaxReplyMessage]; + DWORD dwOptions; + DWORD dwServerOptions; + } +} +alias RASPPPLCPA* LPRASPPPLCPA; + +struct RASSLIPW{ + DWORD dwSize; + DWORD dwError; + WCHAR szIpAddress[RAS_MaxIpAddress + 1]; +} +alias RASSLIPW* LPRASSLIPW; + +struct RASSLIPA{ + DWORD dwSize; + DWORD dwError; + CHAR szIpAddress[RAS_MaxIpAddress + 1]; +} +alias RASSLIPA* LPRASSLIPA; + +struct RASDEVINFOW{ + DWORD dwSize; + WCHAR szDeviceType[RAS_MaxDeviceType + 1]; + WCHAR szDeviceName[RAS_MaxDeviceName + 1]; +} +alias RASDEVINFOW* LPRASDEVINFOW; + +struct RASDEVINFOA{ + DWORD dwSize; + CHAR szDeviceType[RAS_MaxDeviceType + 1]; + CHAR szDeviceName[RAS_MaxDeviceName + 1]; +} +alias RASDEVINFOA* LPRASDEVINFOA; + +struct RASCTRYINFO { + DWORD dwSize; + DWORD dwCountryID; + DWORD dwNextCountryID; + DWORD dwCountryCode; + DWORD dwCountryNameOffset; +} +alias RASCTRYINFO* LPRASCTRYINFO; +alias RASCTRYINFO RASCTRYINFOW, RASCTRYINFOA; +alias RASCTRYINFOW* LPRASCTRYINFOW; +alias RASCTRYINFOA* LPRASCTRYINFOA; + +struct RASIPADDR { + BYTE a; + BYTE b; + BYTE c; + BYTE d; +} + +struct RASENTRYW { + DWORD dwSize; + DWORD dwfOptions; + DWORD dwCountryID; + DWORD dwCountryCode; + WCHAR szAreaCode[RAS_MaxAreaCode + 1]; + WCHAR szLocalPhoneNumber[RAS_MaxPhoneNumber + 1]; + DWORD dwAlternateOffset; + RASIPADDR ipaddr; + RASIPADDR ipaddrDns; + RASIPADDR ipaddrDnsAlt; + RASIPADDR ipaddrWins; + RASIPADDR ipaddrWinsAlt; + DWORD dwFrameSize; + DWORD dwfNetProtocols; + DWORD dwFramingProtocol; + WCHAR szScript[MAX_PATH]; + WCHAR szAutodialDll[MAX_PATH]; + WCHAR szAutodialFunc[MAX_PATH]; + WCHAR szDeviceType[RAS_MaxDeviceType + 1]; + WCHAR szDeviceName[RAS_MaxDeviceName + 1]; + WCHAR szX25PadType[RAS_MaxPadType + 1]; + WCHAR szX25Address[RAS_MaxX25Address + 1]; + WCHAR szX25Facilities[RAS_MaxFacilities + 1]; + WCHAR szX25UserData[RAS_MaxUserData + 1]; + DWORD dwChannels; + DWORD dwReserved1; + DWORD dwReserved2; + static if (WINVER >= 0x0401) { + DWORD dwSubEntries; + DWORD dwDialMode; + DWORD dwDialExtraPercent; + DWORD dwDialExtraSampleSeconds; + DWORD dwHangUpExtraPercent; + DWORD dwHangUpExtraSampleSeconds; + DWORD dwIdleDisconnectSeconds; + } + static if (WINVER >= 0x0500) { + DWORD dwType; + DWORD dwEncryptionType; + DWORD dwCustomAuthKey; + GUID guidId; + WCHAR szCustomDialDll[MAX_PATH]; + DWORD dwVpnStrategy; + } +} +alias RASENTRYW* LPRASENTRYW; + +struct RASENTRYA { + DWORD dwSize; + DWORD dwfOptions; + DWORD dwCountryID; + DWORD dwCountryCode; + CHAR szAreaCode[RAS_MaxAreaCode + 1]; + CHAR szLocalPhoneNumber[RAS_MaxPhoneNumber + 1]; + DWORD dwAlternateOffset; + RASIPADDR ipaddr; + RASIPADDR ipaddrDns; + RASIPADDR ipaddrDnsAlt; + RASIPADDR ipaddrWins; + RASIPADDR ipaddrWinsAlt; + DWORD dwFrameSize; + DWORD dwfNetProtocols; + DWORD dwFramingProtocol; + CHAR szScript[MAX_PATH]; + CHAR szAutodialDll[MAX_PATH]; + CHAR szAutodialFunc[MAX_PATH]; + CHAR szDeviceType[RAS_MaxDeviceType + 1]; + CHAR szDeviceName[RAS_MaxDeviceName + 1]; + CHAR szX25PadType[RAS_MaxPadType + 1]; + CHAR szX25Address[RAS_MaxX25Address + 1]; + CHAR szX25Facilities[RAS_MaxFacilities + 1]; + CHAR szX25UserData[RAS_MaxUserData + 1]; + DWORD dwChannels; + DWORD dwReserved1; + DWORD dwReserved2; + static if (WINVER >= 0x0401) { + DWORD dwSubEntries; + DWORD dwDialMode; + DWORD dwDialExtraPercent; + DWORD dwDialExtraSampleSeconds; + DWORD dwHangUpExtraPercent; + DWORD dwHangUpExtraSampleSeconds; + DWORD dwIdleDisconnectSeconds; + } + static if (WINVER >= 0x0500) { + DWORD dwType; + DWORD dwEncryptionType; + DWORD dwCustomAuthKey; + GUID guidId; + CHAR szCustomDialDll[MAX_PATH]; + DWORD dwVpnStrategy; + } +} +alias RASENTRYA* LPRASENTRYA; + + +static if (WINVER >= 0x0401) { + struct RASADPARAMS { + DWORD dwSize; + HWND hwndOwner; + DWORD dwFlags; + LONG xDlg; + LONG yDlg; + } + alias RASADPARAMS* LPRASADPARAMS; + + struct RASSUBENTRYW{ + DWORD dwSize; + DWORD dwfFlags; + WCHAR szDeviceType[RAS_MaxDeviceType + 1]; + WCHAR szDeviceName[RAS_MaxDeviceName + 1]; + WCHAR szLocalPhoneNumber[RAS_MaxPhoneNumber + 1]; + DWORD dwAlternateOffset; + } + alias RASSUBENTRYW* LPRASSUBENTRYW; + + struct RASSUBENTRYA{ + DWORD dwSize; + DWORD dwfFlags; + CHAR szDeviceType[RAS_MaxDeviceType + 1]; + CHAR szDeviceName[RAS_MaxDeviceName + 1]; + CHAR szLocalPhoneNumber[RAS_MaxPhoneNumber + 1]; + DWORD dwAlternateOffset; + } + alias RASSUBENTRYA* LPRASSUBENTRYA; + + struct RASCREDENTIALSW{ + DWORD dwSize; + DWORD dwMask; + WCHAR szUserName[UNLEN + 1]; + WCHAR szPassword[PWLEN + 1]; + WCHAR szDomain[DNLEN + 1]; + } + alias RASCREDENTIALSW* LPRASCREDENTIALSW; + + struct RASCREDENTIALSA{ + DWORD dwSize; + DWORD dwMask; + CHAR szUserName[UNLEN + 1]; + CHAR szPassword[PWLEN + 1]; + CHAR szDomain[DNLEN + 1]; + } + alias RASCREDENTIALSA* LPRASCREDENTIALSA; + + struct RASAUTODIALENTRYW{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwDialingLocation; + WCHAR szEntry[RAS_MaxEntryName + 1]; + } + alias RASAUTODIALENTRYW* LPRASAUTODIALENTRYW; + + struct RASAUTODIALENTRYA{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwDialingLocation; + CHAR szEntry[RAS_MaxEntryName + 1]; + } + alias RASAUTODIALENTRYA* LPRASAUTODIALENTRYA; +} + +static if (WINVER >= 0x0500) { + struct RASPPPCCP{ + DWORD dwSize; + DWORD dwError; + DWORD dwCompressionAlgorithm; + DWORD dwOptions; + DWORD dwServerCompressionAlgorithm; + DWORD dwServerOptions; + } + alias RASPPPCCP* LPRASPPPCCP; + + struct RASEAPUSERIDENTITYW{ + WCHAR szUserName[UNLEN + 1]; + DWORD dwSizeofEapInfo; + BYTE pbEapInfo[1]; + } + alias RASEAPUSERIDENTITYW* LPRASEAPUSERIDENTITYW; + + struct RASEAPUSERIDENTITYA{ + CHAR szUserName[UNLEN + 1]; + DWORD dwSizeofEapInfo; + BYTE pbEapInfo[1]; + } + alias RASEAPUSERIDENTITYA* LPRASEAPUSERIDENTITYA; + + struct RAS_STATS{ + DWORD dwSize; + DWORD dwBytesXmited; + DWORD dwBytesRcved; + DWORD dwFramesXmited; + DWORD dwFramesRcved; + DWORD dwCrcErr; + DWORD dwTimeoutErr; + DWORD dwAlignmentErr; + DWORD dwHardwareOverrunErr; + DWORD dwFramingErr; + DWORD dwBufferOverrunErr; + DWORD dwCompressionRatioIn; + DWORD dwCompressionRatioOut; + DWORD dwBps; + DWORD dwConnectDuration; + } + alias RAS_STATS* PRAS_STATS; +} + + +/* UNICODE typedefs for structures*/ +version (Unicode) { + alias RASCONNW RASCONN; + alias RASENTRYW RASENTRY; + alias RASCONNSTATUSW RASCONNSTATUS; + alias RASDIALPARAMSW RASDIALPARAMS; + alias RASAMBW RASAMB; + alias RASPPPNBFW RASPPPNBF; + alias RASPPPIPXW RASPPPIPX; + alias RASPPPIPW RASPPPIP; + alias RASPPPLCPW RASPPPLCP; + alias RASSLIPW RASSLIP; + alias RASDEVINFOW RASDEVINFO; + alias RASENTRYNAMEW RASENTRYNAME; + + static if (WINVER >= 0x0401) { + alias RASSUBENTRYW RASSUBENTRY; + alias RASCREDENTIALSW RASCREDENTIALS; + alias RASAUTODIALENTRYW RASAUTODIALENTRY; + } + + static if (WINVER >= 0x0500) { + alias RASEAPUSERIDENTITYW RASEAPUSERIDENTITY; + } + +} else { // ! defined UNICODE + + alias RASCONNA RASCONN; + alias RASENTRYA RASENTRY; + alias RASCONNSTATUSA RASCONNSTATUS; + alias RASDIALPARAMSA RASDIALPARAMS; + alias RASAMBA RASAMB; + alias RASPPPNBFA RASPPPNBF; + alias RASPPPIPXA RASPPPIPX; + alias RASPPPIPA RASPPPIP; + alias RASPPPLCPA RASPPPLCP; + alias RASSLIPA RASSLIP; + alias RASDEVINFOA RASDEVINFO; + alias RASENTRYNAMEA RASENTRYNAME; + + static if (WINVER >= 0x0401) { + alias RASSUBENTRYA RASSUBENTRY; + alias RASCREDENTIALSA RASCREDENTIALS; + alias RASAUTODIALENTRYA RASAUTODIALENTRY; + } + static if (WINVER >= 0x0500) { + alias RASEAPUSERIDENTITYA RASEAPUSERIDENTITY; + } +}// ! UNICODE + + +alias RASCONN* LPRASCONN; +alias RASENTRY* LPRASENTRY; +alias RASCONNSTATUS* LPRASCONNSTATUS; +alias RASDIALPARAMS* LPRASDIALPARAMS; +alias RASAMB* LPRASAM; +alias RASPPPNBF* LPRASPPPNBF; +alias RASPPPIPX* LPRASPPPIPX; +alias RASPPPIP* LPRASPPPIP; +alias RASPPPLCP* LPRASPPPLCP; +alias RASSLIP* LPRASSLIP; +alias RASDEVINFO* LPRASDEVINFO; +alias RASENTRYNAME* LPRASENTRYNAME; + +static if (WINVER >= 0x0401) { + alias RASSUBENTRY* LPRASSUBENTRY; + alias RASCREDENTIALS* LPRASCREDENTIALS; + alias RASAUTODIALENTRY* LPRASAUTODIALENTRY; +} +static if (WINVER >= 0x0500) { + alias RASEAPUSERIDENTITY* LPRASEAPUSERIDENTITY; +} + +/* Callback prototypes */ +deprecated { + alias BOOL function (HWND, LPSTR, DWORD, LPDWORD) ORASADFUNC; +} + +alias void function (UINT, RASCONNSTATE, DWORD) RASDIALFUNC; +alias void function(HRASCONN, UINT, RASCONNSTATE, DWORD, +DWORD) RASDIALFUNC1; +alias DWORD function (ULONG_PTR, DWORD, HRASCONN, UINT, +RASCONNSTATE, DWORD, DWORD) RASDIALFUNC2; + +/* External functions */ +DWORD RasDialA (LPRASDIALEXTENSIONS, LPCSTR, LPRASDIALPARAMSA, +DWORD, LPVOID, LPHRASCONN); +DWORD RasDialW (LPRASDIALEXTENSIONS, LPCWSTR, LPRASDIALPARAMSW, +DWORD, LPVOID, LPHRASCONN); +DWORD RasEnumConnectionsA (LPRASCONNA, LPDWORD, LPDWORD); +DWORD RasEnumConnectionsW (LPRASCONNW, LPDWORD, LPDWORD); +DWORD RasEnumEntriesA (LPCSTR, LPCSTR, LPRASENTRYNAMEA, LPDWORD, +LPDWORD); +DWORD RasEnumEntriesW (LPCWSTR, LPCWSTR, LPRASENTRYNAMEW, LPDWORD, +LPDWORD); +DWORD RasGetConnectStatusA (HRASCONN, LPRASCONNSTATUSA); +DWORD RasGetConnectStatusW (HRASCONN, LPRASCONNSTATUSW); +DWORD RasGetErrorStringA (UINT, LPSTR, DWORD); +DWORD RasGetErrorStringW (UINT, LPWSTR, DWORD); +DWORD RasHangUpA (HRASCONN); +DWORD RasHangUpW (HRASCONN); +DWORD RasGetProjectionInfoA (HRASCONN, RASPROJECTION, LPVOID, +LPDWORD); +DWORD RasGetProjectionInfoW (HRASCONN, RASPROJECTION, LPVOID, +LPDWORD); +DWORD RasCreatePhonebookEntryA (HWND, LPCSTR); +DWORD RasCreatePhonebookEntryW (HWND, LPCWSTR); +DWORD RasEditPhonebookEntryA (HWND, LPCSTR, LPCSTR); +DWORD RasEditPhonebookEntryW (HWND, LPCWSTR, LPCWSTR); +DWORD RasSetEntryDialParamsA (LPCSTR, LPRASDIALPARAMSA, BOOL); +DWORD RasSetEntryDialParamsW (LPCWSTR, LPRASDIALPARAMSW, BOOL); +DWORD RasGetEntryDialParamsA (LPCSTR, LPRASDIALPARAMSA, LPBOOL); +DWORD RasGetEntryDialParamsW (LPCWSTR, LPRASDIALPARAMSW, LPBOOL); +DWORD RasEnumDevicesA (LPRASDEVINFOA, LPDWORD, LPDWORD); +DWORD RasEnumDevicesW (LPRASDEVINFOW, LPDWORD, LPDWORD); +DWORD RasGetCountryInfoA (LPRASCTRYINFOA, LPDWORD); +DWORD RasGetCountryInfoW (LPRASCTRYINFOW, LPDWORD); +DWORD RasGetEntryPropertiesA (LPCSTR, LPCSTR, LPRASENTRYA, LPDWORD, +LPBYTE, LPDWORD); +DWORD RasGetEntryPropertiesW (LPCWSTR, LPCWSTR, LPRASENTRYW, +LPDWORD, LPBYTE, LPDWORD); +DWORD RasSetEntryPropertiesA (LPCSTR, LPCSTR, LPRASENTRYA, DWORD, +LPBYTE, DWORD); +DWORD RasSetEntryPropertiesW (LPCWSTR, LPCWSTR, LPRASENTRYW, DWORD, +LPBYTE, DWORD); +DWORD RasRenameEntryA (LPCSTR, LPCSTR, LPCSTR); +DWORD RasRenameEntryW (LPCWSTR, LPCWSTR, LPCWSTR); +DWORD RasDeleteEntryA (LPCSTR, LPCSTR); +DWORD RasDeleteEntryW (LPCWSTR, LPCWSTR); +DWORD RasValidateEntryNameA (LPCSTR, LPCSTR); +DWORD RasValidateEntryNameW (LPCWSTR, LPCWSTR); + +static if (WINVER >= 0x0401) { + alias BOOL function (LPSTR, LPSTR, LPRASADPARAMS, LPDWORD) RASADFUNCA; + alias BOOL function (LPWSTR, LPWSTR, LPRASADPARAMS, LPDWORD) RASADFUNCW; + + DWORD RasGetSubEntryHandleA (HRASCONN, DWORD, LPHRASCONN); + DWORD RasGetSubEntryHandleW (HRASCONN, DWORD, LPHRASCONN); + DWORD RasGetCredentialsA (LPCSTR, LPCSTR, LPRASCREDENTIALSA); + DWORD RasGetCredentialsW (LPCWSTR, LPCWSTR, LPRASCREDENTIALSW); + DWORD RasSetCredentialsA (LPCSTR, LPCSTR, LPRASCREDENTIALSA, BOOL); + DWORD RasSetCredentialsW (LPCWSTR, LPCWSTR, LPRASCREDENTIALSW, BOOL); + DWORD RasConnectionNotificationA (HRASCONN, HANDLE, DWORD); + DWORD RasConnectionNotificationW (HRASCONN, HANDLE, DWORD); + DWORD RasGetSubEntryPropertiesA (LPCSTR, LPCSTR, DWORD, + LPRASSUBENTRYA, LPDWORD, LPBYTE, LPDWORD); + DWORD RasGetSubEntryPropertiesW (LPCWSTR, LPCWSTR, DWORD, + LPRASSUBENTRYW, LPDWORD, LPBYTE, LPDWORD); + DWORD RasSetSubEntryPropertiesA (LPCSTR, LPCSTR, DWORD, + LPRASSUBENTRYA, DWORD, LPBYTE, DWORD); + DWORD RasSetSubEntryPropertiesW (LPCWSTR, LPCWSTR, DWORD, + LPRASSUBENTRYW, DWORD, LPBYTE, DWORD); + DWORD RasGetAutodialAddressA (LPCSTR, LPDWORD, LPRASAUTODIALENTRYA, + LPDWORD, LPDWORD); + DWORD RasGetAutodialAddressW (LPCWSTR, LPDWORD, + LPRASAUTODIALENTRYW, LPDWORD, LPDWORD); + DWORD RasSetAutodialAddressA (LPCSTR, DWORD, LPRASAUTODIALENTRYA, + DWORD, DWORD); + DWORD RasSetAutodialAddressW (LPCWSTR, DWORD, LPRASAUTODIALENTRYW, + DWORD, DWORD); + DWORD RasEnumAutodialAddressesA (LPSTR *, LPDWORD, LPDWORD); + DWORD RasEnumAutodialAddressesW (LPWSTR *, LPDWORD, LPDWORD); + DWORD RasGetAutodialEnableA (DWORD, LPBOOL); + DWORD RasGetAutodialEnableW (DWORD, LPBOOL); + DWORD RasSetAutodialEnableA (DWORD, BOOL); + DWORD RasSetAutodialEnableW (DWORD, BOOL); + DWORD RasGetAutodialParamA (DWORD, LPVOID, LPDWORD); + DWORD RasGetAutodialParamW (DWORD, LPVOID, LPDWORD); + DWORD RasSetAutodialParamA (DWORD, LPVOID, DWORD); + DWORD RasSetAutodialParamW (DWORD, LPVOID, DWORD); +} + +static if (WINVER >= 0x0500) { + alias DWORD function (HRASCONN) RasCustomHangUpFn; + alias DWORD function (LPCTSTR, LPCTSTR, DWORD) RasCustomDeleteEntryNotifyFn; + alias DWORD function (HINSTANCE, LPRASDIALEXTENSIONS, + LPCTSTR, LPRASDIALPARAMS, DWORD, LPVOID, LPHRASCONN, DWORD) RasCustomDialFn; + + DWORD RasInvokeEapUI (HRASCONN, DWORD, LPRASDIALEXTENSIONS, HWND); + DWORD RasGetLinkStatistics (HRASCONN, DWORD, RAS_STATS*); + DWORD RasGetConnectionStatistics (HRASCONN, RAS_STATS*); + DWORD RasClearLinkStatistics (HRASCONN, DWORD); + DWORD RasClearConnectionStatistics (HRASCONN); + DWORD RasGetEapUserDataA (HANDLE, LPCSTR, LPCSTR, BYTE*, DWORD*); + DWORD RasGetEapUserDataW (HANDLE, LPCWSTR, LPCWSTR, BYTE*, DWORD*); + DWORD RasSetEapUserDataA (HANDLE, LPCSTR, LPCSTR, BYTE*, DWORD); + DWORD RasSetEapUserDataW (HANDLE, LPCWSTR, LPCWSTR, BYTE*, DWORD); + DWORD RasGetCustomAuthDataA (LPCSTR, LPCSTR, BYTE*, DWORD*); + DWORD RasGetCustomAuthDataW (LPCWSTR, LPCWSTR, BYTE*, DWORD*); + DWORD RasSetCustomAuthDataA (LPCSTR, LPCSTR, BYTE*, DWORD); + DWORD RasSetCustomAuthDataW (LPCWSTR, LPCWSTR, BYTE*, DWORD); + DWORD RasGetEapUserIdentityW (LPCWSTR, LPCWSTR, DWORD, HWND, LPRASEAPUSERIDENTITYW*); + DWORD RasGetEapUserIdentityA (LPCSTR, LPCSTR, DWORD, HWND, LPRASEAPUSERIDENTITYA*); + void RasFreeEapUserIdentityW (LPRASEAPUSERIDENTITYW); + void RasFreeEapUserIdentityA (LPRASEAPUSERIDENTITYA); +} + + +/* UNICODE defines for functions */ +version(Unicode) { + alias RasDialW RasDial; + alias RasEnumConnectionsW RasEnumConnections; + alias RasEnumEntriesW RasEnumEntries; + alias RasGetConnectStatusW RasGetConnectStatus; + alias RasGetErrorStringW RasGetErrorString; + alias RasHangUpW RasHangUp; + alias RasGetProjectionInfoW RasGetProjectionInfo; + alias RasCreatePhonebookEntryW RasCreatePhonebookEntry; + alias RasEditPhonebookEntryW RasEditPhonebookEntry; + alias RasSetEntryDialParamsW RasSetEntryDialParams; + alias RasGetEntryDialParamsW RasGetEntryDialParams; + alias RasEnumDevicesW RasEnumDevices; + alias RasGetCountryInfoW RasGetCountryInfo; + alias RasGetEntryPropertiesW RasGetEntryProperties; + alias RasSetEntryPropertiesW RasSetEntryProperties; + alias RasRenameEntryW RasRenameEntry; + alias RasDeleteEntryW RasDeleteEntry; + alias RasValidateEntryNameW RasValidateEntryName; + + static if (WINVER >= 0x0401) { + alias RASADFUNCW RASADFUNC; + alias RasGetSubEntryHandleW RasGetSubEntryHandle; + alias RasConnectionNotificationW RasConnectionNotification; + alias RasGetSubEntryPropertiesW RasGetSubEntryProperties; + alias RasSetSubEntryPropertiesW RasSetSubEntryProperties; + alias RasGetCredentialsW RasGetCredentials; + alias RasSetCredentialsW RasSetCredentials; + alias RasGetAutodialAddressW RasGetAutodialAddress; + alias RasSetAutodialAddressW RasSetAutodialAddress; + alias RasEnumAutodialAddressesW RasEnumAutodialAddresses; + alias RasGetAutodialEnableW RasGetAutodialEnable; + alias RasSetAutodialEnableW RasSetAutodialEnable; + alias RasGetAutodialParamW RasGetAutodialParam; + alias RasSetAutodialParamW RasSetAutodialParam; + } + + static if (WINVER >= 0x0500) { + alias RasGetEapUserDataW RasGetEapUserData; + alias RasSetEapUserDataW RasSetEapUserData; + alias RasGetCustomAuthDataW RasGetCustomAuthData; + alias RasSetCustomAuthDataW RasSetCustomAuthData; + alias RasGetEapUserIdentityW RasGetEapUserIdentity; + alias RasFreeEapUserIdentityW RasFreeEapUserIdentity; + } + +} else { // ! defined UNICODE + alias RasDialA RasDial; + alias RasEnumConnectionsA RasEnumConnections; + alias RasEnumEntriesA RasEnumEntries; + alias RasGetConnectStatusA RasGetConnectStatus; + alias RasGetErrorStringA RasGetErrorString; + alias RasHangUpA RasHangUp; + alias RasGetProjectionInfoA RasGetProjectionInfo; + alias RasCreatePhonebookEntryA RasCreatePhonebookEntry; + alias RasEditPhonebookEntryA RasEditPhonebookEntry; + alias RasSetEntryDialParamsA RasSetEntryDialParams; + alias RasGetEntryDialParamsA RasGetEntryDialParams; + alias RasEnumDevicesA RasEnumDevices; + alias RasGetCountryInfoA RasGetCountryInfo; + alias RasGetEntryPropertiesA RasGetEntryProperties; + alias RasSetEntryPropertiesA RasSetEntryProperties; + alias RasRenameEntryA RasRenameEntry; + alias RasDeleteEntryA RasDeleteEntry; + alias RasValidateEntryNameA RasValidateEntryName; + + static if (WINVER >= 0x0401) { + alias RASADFUNCA RASADFUNC; + alias RasGetSubEntryHandleA RasGetSubEntryHandle; + alias RasConnectionNotificationA RasConnectionNotification; + alias RasGetSubEntryPropertiesA RasGetSubEntryProperties; + alias RasSetSubEntryPropertiesA RasSetSubEntryProperties; + alias RasGetCredentialsA RasGetCredentials; + alias RasSetCredentialsA RasSetCredentials; + alias RasGetAutodialAddressA RasGetAutodialAddress; + alias RasSetAutodialAddressA RasSetAutodialAddress; + alias RasEnumAutodialAddressesA RasEnumAutodialAddresses; + alias RasGetAutodialEnableA RasGetAutodialEnable; + alias RasSetAutodialEnableA RasSetAutodialEnable; + alias RasGetAutodialParamA RasGetAutodialParam; + alias RasSetAutodialParamA RasSetAutodialParam; + } + + static if (WINVER >= 0x0500) { + alias RasGetEapUserDataA RasGetEapUserData; + alias RasSetEapUserDataA RasSetEapUserData; + alias RasGetCustomAuthDataA RasGetCustomAuthData; + alias RasSetCustomAuthDataA RasSetCustomAuthData; + alias RasGetEapUserIdentityA RasGetEapUserIdentity; + alias RasFreeEapUserIdentityA RasFreeEapUserIdentity; + } +} //#endif // ! UNICODE