/**
* Windows API header module
*
* Translated from MinGW Windows headers
*
* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(DRUNTIMESRC core/sys/windows/_ras.d)
*/
module core.sys.windows.ras;
version (Windows):
version (ANSI) {} else version = Unicode;
pragma(lib, "rasapi32");
import core.sys.windows.basetyps, core.sys.windows.lmcons, core.sys.windows.w32api, core.sys.windows.windef;
align(4):
enum RAS_MaxDeviceType = 16;
enum RAS_MaxPhoneNumber = 128;
enum RAS_MaxIpAddress = 15;
enum RAS_MaxIpxAddress = 21;
enum RAS_MaxEntryName = 256;
enum RAS_MaxDeviceName = 128;
enum RAS_MaxCallbackNumber = RAS_MaxPhoneNumber;
enum RAS_MaxAreaCode = 10;
enum RAS_MaxPadType = 32;
enum RAS_MaxX25Address = 200;
enum RAS_MaxFacilities = 200;
enum RAS_MaxUserData = 200;
enum RAS_MaxReplyMessage = 1024;
enum RDEOPT_UsePrefixSuffix = 0x00000001;
enum RDEOPT_PausedStates = 0x00000002;
enum RDEOPT_IgnoreModemSpeaker = 0x00000004;
enum RDEOPT_SetModemSpeaker = 0x00000008;
enum RDEOPT_IgnoreSoftwareCompression = 0x00000010;
enum RDEOPT_SetSoftwareCompression = 0x00000020;
enum RDEOPT_DisableConnectedUI = 0x00000040;
enum RDEOPT_DisableReconnectUI = 0x00000080;
enum RDEOPT_DisableReconnect = 0x00000100;
enum RDEOPT_NoUser = 0x00000200;
enum RDEOPT_PauseOnScript = 0x00000400;
enum RDEOPT_Router = 0x00000800;
enum REN_User = 0x00000000;
enum REN_AllUsers = 0x00000001;
enum VS_Default = 0;
enum VS_PptpOnly = 1;
enum VS_PptpFirst = 2;
enum VS_L2tpOnly = 3;
enum VS_L2tpFirst = 4;
enum RASDIALEVENT = "RasDialEvent";
enum WM_RASDIALEVENT = 0xCCCD;
enum RASEO_UseCountryAndAreaCodes = 0x00000001;
enum RASEO_SpecificIpAddr = 0x00000002;
enum RASEO_SpecificNameServers = 0x00000004;
enum RASEO_IpHeaderCompression = 0x00000008;
enum RASEO_RemoteDefaultGateway = 0x00000010;
enum RASEO_DisableLcpExtensions = 0x00000020;
enum RASEO_TerminalBeforeDial = 0x00000040;
enum RASEO_TerminalAfterDial = 0x00000080;
enum RASEO_ModemLights = 0x00000100;
enum RASEO_SwCompression = 0x00000200;
enum RASEO_RequireEncryptedPw = 0x00000400;
enum RASEO_RequireMsEncryptedPw = 0x00000800;
enum RASEO_RequireDataEncryption = 0x00001000;
enum RASEO_NetworkLogon = 0x00002000;
enum RASEO_UseLogonCredentials = 0x00004000;
enum RASEO_PromoteAlternates = 0x00008000;
enum RASNP_NetBEUI = 0x00000001;
enum RASNP_Ipx = 0x00000002;
enum RASNP_Ip = 0x00000004;
enum RASFP_Ppp = 0x00000001;
enum RASFP_Slip = 0x00000002;
enum 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";
enum RASET_Phone = 1;
enum RASET_Vpn = 2;
enum RASET_Direct = 3;
enum RASET_Internet = 4;
static if (_WIN32_WINNT >= 0x401) {
enum RASEO_SecureLocalFiles = 0x00010000;
enum RASCN_Connection = 0x00000001;
enum RASCN_Disconnection = 0x00000002;
enum RASCN_BandwidthAdded = 0x00000004;
enum RASCN_BandwidthRemoved = 0x00000008;
enum RASEDM_DialAll = 1;
enum RASEDM_DialAsNeeded = 2;
enum RASIDS_Disabled = 0xffffffff;
enum RASIDS_UseGlobalValue = 0;
enum RASADFLG_PositionDlg = 0x00000001;
enum RASCM_UserName = 0x00000001;
enum RASCM_Password = 0x00000002;
enum RASCM_Domain = 0x00000004;
enum RASADP_DisableConnectionQuery = 0;
enum RASADP_LoginSessionDisable = 1;
enum RASADP_SavedAddressesLimit = 2;
enum RASADP_FailedConnectionTimeout = 3;
enum RASADP_ConnectionQueryTimeout = 4;
}
//static if (_WIN32_WINNT >= 0x500) {
enum RDEOPT_CustomDial = 0x00001000;
enum RASLCPAP_PAP = 0xC023;
enum RASLCPAP_SPAP = 0xC027;
enum RASLCPAP_CHAP = 0xC223;
enum RASLCPAP_EAP = 0xC227;
enum RASLCPAD_CHAP_MD5 = 0x05;
enum RASLCPAD_CHAP_MS = 0x80;
enum RASLCPAD_CHAP_MSV2 = 0x81;
enum RASLCPO_PFC = 0x00000001;
enum RASLCPO_ACFC = 0x00000002;
enum RASLCPO_SSHF = 0x00000004;
enum RASLCPO_DES_56 = 0x00000008;
enum RASLCPO_3_DES = 0x00000010;
enum RASCCPCA_MPPC = 0x00000006;
enum RASCCPCA_STAC = 0x00000005;
enum RASCCPO_Compression = 0x00000001;
enum RASCCPO_HistoryLess = 0x00000002;
enum RASCCPO_Encryption56bit = 0x00000010;
enum RASCCPO_Encryption40bit = 0x00000020;
enum RASCCPO_Encryption128bit = 0x00000040;
enum RASEO_RequireEAP = 0x00020000;
enum RASEO_RequirePAP = 0x00040000;
enum RASEO_RequireSPAP = 0x00080000;
enum RASEO_Custom = 0x00100000;
enum RASEO_PreviewPhoneNumber = 0x00200000;
enum RASEO_SharedPhoneNumbers = 0x00800000;
enum RASEO_PreviewUserPw = 0x01000000;
enum RASEO_PreviewDomain = 0x02000000;
enum RASEO_ShowDialingProgress = 0x04000000;
enum RASEO_RequireCHAP = 0x08000000;
enum RASEO_RequireMsCHAP = 0x10000000;
enum RASEO_RequireMsCHAP2 = 0x20000000;
enum RASEO_RequireW95MSCHAP = 0x40000000;
enum RASEO_CustomScript = 0x80000000;
enum RASIPO_VJ = 0x00000001;
enum RCD_SingleUser = 0;
enum RCD_AllUsers = 0x00000001;
enum RCD_Eap = 0x00000002;
enum RASEAPF_NonInteractive = 0x00000002;
enum RASEAPF_Logon = 0x00000004;
enum RASEAPF_Preview = 0x00000008;
enum ET_40Bit = 1;
enum ET_128Bit = 2;
enum ET_None = 0;
enum ET_Require = 1;
enum ET_RequireMax = 2;
enum ET_Optional = 3;
//}
enum RASCS_PAUSED = 0x1000;
enum 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 (_WIN32_WINNT >= 0x500) {
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 (_WIN32_WINNT >= 0x500) {
RASP_PppCcp = 0x80FD,
// }
RASP_PppLcp = 0xC021,
RASP_Slip = 0x20000
}
alias RASPROJECTION* LPRASPROJECTION;
alias TypeDef!(HANDLE) HRASCONN;
alias HRASCONN* LPHRASCONN;
struct RASCONNW {
align(4):
DWORD dwSize;
HRASCONN hrasconn;
align {
WCHAR[RAS_MaxEntryName + 1] szEntryName = 0;
WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
}
//static if (_WIN32_WINNT >= 0x401) {
WCHAR[MAX_PATH] szPhonebook = 0;
DWORD dwSubEntry;
//}
//static if (_WIN32_WINNT >= 0x500) {
GUID guidEntry;
//}
static if (_WIN32_WINNT >= 0x501) {
DWORD dwFlags;
LUID luid;
}
}
alias RASCONNW* LPRASCONNW;
struct RASCONNA {
align(4):
DWORD dwSize;
HRASCONN hrasconn;
align {
CHAR[RAS_MaxEntryName + 1] szEntryName = 0;
CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
}
//static if (_WIN32_WINNT >= 0x401) {
CHAR[MAX_PATH] szPhonebook = 0;
DWORD dwSubEntry;
//}
//static if (_WIN32_WINNT >= 0x500) {
GUID guidEntry;
//}
static if (_WIN32_WINNT >= 0x501) {
DWORD dwFlags;
LUID luid;
}
}
alias RASCONNA* LPRASCONNA;
struct RASCONNSTATUSW {
DWORD dwSize;
RASCONNSTATE rasconnstate;
DWORD dwError;
WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
static if (_WIN32_WINNT >= 0x401) {
WCHAR[RAS_MaxPhoneNumber + 1] szPhoneNumber = 0;
}
}
alias RASCONNSTATUSW* LPRASCONNSTATUSW;
struct RASCONNSTATUSA {
DWORD dwSize;
RASCONNSTATE rasconnstate;
DWORD dwError;
CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
static if (_WIN32_WINNT >= 0x401) {
CHAR[RAS_MaxPhoneNumber + 1] szPhoneNumber = 0;
}
}
alias RASCONNSTATUSA* LPRASCONNSTATUSA;
struct RASDIALPARAMSW {
align(4):
DWORD dwSize;
align {
WCHAR[RAS_MaxEntryName + 1] szEntryName = 0;
WCHAR[RAS_MaxPhoneNumber + 1] szPhoneNumber = 0;
WCHAR[RAS_MaxCallbackNumber + 1] szCallbackNumber = 0;
WCHAR[UNLEN + 1] szUserName = 0;
WCHAR[PWLEN + 1] szPassword = 0;
WCHAR[DNLEN + 1] szDomain = 0;
}
static if (_WIN32_WINNT >= 0x401) {
DWORD dwSubEntry;
ULONG_PTR dwCallbackId;
}
}
alias RASDIALPARAMSW* LPRASDIALPARAMSW;
struct RASDIALPARAMSA{
align(4):
DWORD dwSize;
align {
CHAR[RAS_MaxEntryName + 1] szEntryName = 0;
CHAR[RAS_MaxPhoneNumber + 1] szPhoneNumber = 0;
CHAR[RAS_MaxCallbackNumber + 1] szCallbackNumber = 0;
CHAR[UNLEN + 1] szUserName = 0;
CHAR[PWLEN + 1] szPassword = 0;
CHAR[DNLEN + 1] szDomain = 0;
}
static if (_WIN32_WINNT >= 0x401) {
DWORD dwSubEntry;
ULONG_PTR dwCallbackId;
}
}
alias RASDIALPARAMSA* LPRASDIALPARAMSA;
//static if (_WIN32_WINNT >= 0x500) {
struct RASEAPINFO {
align(4):
DWORD dwSizeofEapInfo;
BYTE *pbEapInfo;
}
//}
struct RASDIALEXTENSIONS {
align(4):
DWORD dwSize;
DWORD dwfOptions;
HWND hwndParent;
ULONG_PTR reserved;
//static if (_WIN32_WINNT >= 0x500) {
ULONG_PTR reserved1;
RASEAPINFO RasEapInfo;
//}
}
alias RASDIALEXTENSIONS* LPRASDIALEXTENSIONS;
struct RASENTRYNAMEW {
DWORD dwSize;
WCHAR[RAS_MaxEntryName + 1] szEntryName = 0;
//static if (_WIN32_WINNT >= 0x500) {
DWORD dwFlags;
WCHAR[MAX_PATH + 1] szPhonebookPath = 0;
//}
}
alias RASENTRYNAMEW* LPRASENTRYNAMEW;
struct RASENTRYNAMEA{
DWORD dwSize;
CHAR[RAS_MaxEntryName + 1] szEntryName = 0;
//static if (_WIN32_WINNT >= 0x500) {
DWORD dwFlags;
CHAR[MAX_PATH + 1] szPhonebookPath = 0;
//}
}
alias RASENTRYNAMEA* LPRASENTRYNAMEA;
struct RASAMBW{
DWORD dwSize;
DWORD dwError;
WCHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0;
BYTE bLana;
}
alias RASAMBW* LPRASAMBW;
struct RASAMBA{
DWORD dwSize;
DWORD dwError;
CHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0;
BYTE bLana;
}
alias RASAMBA* LPRASAMBA;
struct RASPPPNBFW{
DWORD dwSize;
DWORD dwError;
DWORD dwNetBiosError;
WCHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0;
WCHAR[NETBIOS_NAME_LEN + 1] szWorkstationName = 0;
BYTE bLana;
}
alias RASPPPNBFW* LPRASPPPNBFW;
struct RASPPPNBFA{
DWORD dwSize;
DWORD dwError;
DWORD dwNetBiosError;
CHAR[NETBIOS_NAME_LEN + 1] szNetBiosError = 0;
CHAR[NETBIOS_NAME_LEN + 1] szWorkstationName = 0;
BYTE bLana;
}
alias RASPPPNBFA* LPRASPPPNBFA;
struct RASPPPIPXW {
DWORD dwSize;
DWORD dwError;
WCHAR[RAS_MaxIpxAddress + 1] szIpxAddress = 0;
}
alias RASPPPIPXW* LPRASPPPIPXW;
struct RASPPPIPXA {
DWORD dwSize;
DWORD dwError;
CHAR[RAS_MaxIpxAddress + 1] szIpxAddress = 0;
}
alias RASPPPIPXA* LPRASPPPIPXA;
struct RASPPPIPW{
DWORD dwSize;
DWORD dwError;
WCHAR[RAS_MaxIpAddress + 1] szIpAddress = 0;
//#ifndef WINNT35COMPATIBLE
WCHAR[RAS_MaxIpAddress + 1] szServerIpAddress = 0;
//#endif
//static if (_WIN32_WINNT >= 0x500) {
DWORD dwOptions;
DWORD dwServerOptions;
//}
}
alias RASPPPIPW* LPRASPPPIPW;
struct RASPPPIPA{
DWORD dwSize;
DWORD dwError;
CHAR[RAS_MaxIpAddress + 1] szIpAddress = 0;
//#ifndef WINNT35COMPATIBLE
CHAR[RAS_MaxIpAddress + 1] szServerIpAddress = 0;
//#endif
//static if (_WIN32_WINNT >= 0x500) {
DWORD dwOptions;
DWORD dwServerOptions;
//}
}
alias RASPPPIPA* LPRASPPPIPA;
struct RASPPPLCPW{
DWORD dwSize;
BOOL fBundled;
//static if (_WIN32_WINNT >= 0x500) {
DWORD dwError;
DWORD dwAuthenticationProtocol;
DWORD dwAuthenticationData;
DWORD dwEapTypeId;
DWORD dwServerAuthenticationProtocol;
DWORD dwServerAuthenticationData;
DWORD dwServerEapTypeId;
BOOL fMultilink;
DWORD dwTerminateReason;
DWORD dwServerTerminateReason;
WCHAR[RAS_MaxReplyMessage] szReplyMessage = 0;
DWORD dwOptions;
DWORD dwServerOptions;
//}
}
alias RASPPPLCPW* LPRASPPPLCPW;
struct RASPPPLCPA{
DWORD dwSize;
BOOL fBundled;
//static if (_WIN32_WINNT >= 0x500) {
DWORD dwError;
DWORD dwAuthenticationProtocol;
DWORD dwAuthenticationData;
DWORD dwEapTypeId;
DWORD dwServerAuthenticationProtocol;
DWORD dwServerAuthenticationData;
DWORD dwServerEapTypeId;
BOOL fMultilink;
DWORD dwTerminateReason;
DWORD dwServerTerminateReason;
CHAR[RAS_MaxReplyMessage] szReplyMessage = 0;
DWORD dwOptions;
DWORD dwServerOptions;
//}
}
alias RASPPPLCPA* LPRASPPPLCPA;
struct RASSLIPW{
DWORD dwSize;
DWORD dwError;
WCHAR[RAS_MaxIpAddress + 1] szIpAddress = 0;
}
alias RASSLIPW* LPRASSLIPW;
struct RASSLIPA{
DWORD dwSize;
DWORD dwError;
CHAR[RAS_MaxIpAddress + 1] szIpAddress = 0;
}
alias RASSLIPA* LPRASSLIPA;
struct RASDEVINFOW{
DWORD dwSize;
WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
}
alias RASDEVINFOW* LPRASDEVINFOW;
struct RASDEVINFOA{
DWORD dwSize;
CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
}
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[RAS_MaxAreaCode + 1] szAreaCode = 0;
WCHAR[RAS_MaxPhoneNumber + 1] szLocalPhoneNumber = 0;
DWORD dwAlternateOffset;
RASIPADDR ipaddr;
RASIPADDR ipaddrDns;
RASIPADDR ipaddrDnsAlt;
RASIPADDR ipaddrWins;
RASIPADDR ipaddrWinsAlt;
DWORD dwFrameSize;
DWORD dwfNetProtocols;
DWORD dwFramingProtocol;
WCHAR[MAX_PATH] szScript = 0;
WCHAR[MAX_PATH] szAutodialDll = 0;
WCHAR[MAX_PATH] szAutodialFunc = 0;
WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
WCHAR[RAS_MaxPadType + 1] szX25PadType = 0;
WCHAR[RAS_MaxX25Address + 1] szX25Address = 0;
WCHAR[RAS_MaxFacilities + 1] szX25Facilities = 0;
WCHAR[RAS_MaxUserData + 1] szX25UserData = 0;
DWORD dwChannels;
DWORD dwReserved1;
DWORD dwReserved2;
//static if (_WIN32_WINNT >= 0x401) {
DWORD dwSubEntries;
DWORD dwDialMode;
DWORD dwDialExtraPercent;
DWORD dwDialExtraSampleSeconds;
DWORD dwHangUpExtraPercent;
DWORD dwHangUpExtraSampleSeconds;
DWORD dwIdleDisconnectSeconds;
//}
//static if (_WIN32_WINNT >= 0x500) {
DWORD dwType;
DWORD dwEncryptionType;
DWORD dwCustomAuthKey;
GUID guidId;
WCHAR[MAX_PATH] szCustomDialDll = 0;
DWORD dwVpnStrategy;
//}
}
alias RASENTRYW* LPRASENTRYW;
struct RASENTRYA {
DWORD dwSize;
DWORD dwfOptions;
DWORD dwCountryID;
DWORD dwCountryCode;
CHAR[RAS_MaxAreaCode + 1] szAreaCode = 0;
CHAR[RAS_MaxPhoneNumber + 1] szLocalPhoneNumber = 0;
DWORD dwAlternateOffset;
RASIPADDR ipaddr;
RASIPADDR ipaddrDns;
RASIPADDR ipaddrDnsAlt;
RASIPADDR ipaddrWins;
RASIPADDR ipaddrWinsAlt;
DWORD dwFrameSize;
DWORD dwfNetProtocols;
DWORD dwFramingProtocol;
CHAR[MAX_PATH] szScript = 0;
CHAR[MAX_PATH] szAutodialDll = 0;
CHAR[MAX_PATH] szAutodialFunc = 0;
CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
CHAR[RAS_MaxPadType + 1] szX25PadType = 0;
CHAR[RAS_MaxX25Address + 1] szX25Address = 0;
CHAR[RAS_MaxFacilities + 1] szX25Facilities = 0;
CHAR[RAS_MaxUserData + 1] szX25UserData = 0;
DWORD dwChannels;
DWORD dwReserved1;
DWORD dwReserved2;
//static if (_WIN32_WINNT >= 0x401) {
DWORD dwSubEntries;
DWORD dwDialMode;
DWORD dwDialExtraPercent;
DWORD dwDialExtraSampleSeconds;
DWORD dwHangUpExtraPercent;
DWORD dwHangUpExtraSampleSeconds;
DWORD dwIdleDisconnectSeconds;
//}
//static if (_WIN32_WINNT >= 0x500) {
DWORD dwType;
DWORD dwEncryptionType;
DWORD dwCustomAuthKey;
GUID guidId;
CHAR[MAX_PATH] szCustomDialDll = 0;
DWORD dwVpnStrategy;
//}
}
alias RASENTRYA* LPRASENTRYA;
//static if (_WIN32_WINNT >= 0x401) {
struct RASADPARAMS {
align(4):
DWORD dwSize;
HWND hwndOwner;
DWORD dwFlags;
LONG xDlg;
LONG yDlg;
}
alias RASADPARAMS* LPRASADPARAMS;
struct RASSUBENTRYW{
DWORD dwSize;
DWORD dwfFlags;
WCHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
WCHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
WCHAR[RAS_MaxPhoneNumber + 1] szLocalPhoneNumber = 0;
DWORD dwAlternateOffset;
}
alias RASSUBENTRYW* LPRASSUBENTRYW;
struct RASSUBENTRYA{
DWORD dwSize;
DWORD dwfFlags;
CHAR[RAS_MaxDeviceType + 1] szDeviceType = 0;
CHAR[RAS_MaxDeviceName + 1] szDeviceName = 0;
CHAR[RAS_MaxPhoneNumber + 1] szLocalPhoneNumber = 0;
DWORD dwAlternateOffset;
}
alias RASSUBENTRYA* LPRASSUBENTRYA;
struct RASCREDENTIALSW{
DWORD dwSize;
DWORD dwMask;
WCHAR[UNLEN + 1] szUserName = 0;
WCHAR[PWLEN + 1] szPassword = 0;
WCHAR[DNLEN + 1] szDomain = 0;
}
alias RASCREDENTIALSW* LPRASCREDENTIALSW;
struct RASCREDENTIALSA{
DWORD dwSize;
DWORD dwMask;
CHAR[UNLEN + 1] szUserName = 0;
CHAR[PWLEN + 1] szPassword = 0;
CHAR[DNLEN + 1] szDomain = 0;
}
alias RASCREDENTIALSA* LPRASCREDENTIALSA;
struct RASAUTODIALENTRYW{
DWORD dwSize;
DWORD dwFlags;
DWORD dwDialingLocation;
WCHAR[RAS_MaxEntryName + 1] szEntry = 0;
}
alias RASAUTODIALENTRYW* LPRASAUTODIALENTRYW;
struct RASAUTODIALENTRYA{
DWORD dwSize;
DWORD dwFlags;
DWORD dwDialingLocation;
CHAR[RAS_MaxEntryName + 1] szEntry = 0;
}
alias RASAUTODIALENTRYA* LPRASAUTODIALENTRYA;
//}
//static if (_WIN32_WINNT >= 0x500) {
struct RASPPPCCP{
DWORD dwSize;
DWORD dwError;
DWORD dwCompressionAlgorithm;
DWORD dwOptions;
DWORD dwServerCompressionAlgorithm;
DWORD dwServerOptions;
}
alias RASPPPCCP* LPRASPPPCCP;
struct RASEAPUSERIDENTITYW{
WCHAR[UNLEN + 1] szUserName = 0;
DWORD dwSizeofEapInfo;
BYTE[1] pbEapInfo;
}
alias RASEAPUSERIDENTITYW* LPRASEAPUSERIDENTITYW;
struct RASEAPUSERIDENTITYA{
CHAR[UNLEN + 1] szUserName = 0;
DWORD dwSizeofEapInfo;
BYTE[1] pbEapInfo;
}
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 (_WIN32_WINNT >= 0x401) {
alias RASSUBENTRYW RASSUBENTRY;
alias RASCREDENTIALSW RASCREDENTIALS;
alias RASAUTODIALENTRYW RASAUTODIALENTRY;
//}
//static if (_WIN32_WINNT >= 0x500) {
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 (_WIN32_WINNT >= 0x401) {
alias RASSUBENTRYA RASSUBENTRY;
alias RASCREDENTIALSA RASCREDENTIALS;
alias RASAUTODIALENTRYA RASAUTODIALENTRY;
//}
//static if (_WIN32_WINNT >= 0x500) {
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 (_WIN32_WINNT >= 0x401) {
alias RASSUBENTRY* LPRASSUBENTRY;
alias RASCREDENTIALS* LPRASCREDENTIALS;
alias RASAUTODIALENTRY* LPRASAUTODIALENTRY;
//}
//static if (_WIN32_WINNT >= 0x500) {
alias RASEAPUSERIDENTITY* LPRASEAPUSERIDENTITY;
//}
/* Callback prototypes */
extern (Windows) { /* WINAPI */
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 (_WIN32_WINNT >= 0x401) {
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 (_WIN32_WINNT >= 0x500) {
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);
}
} // extern (Windows)
/* 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 (_WIN32_WINNT >= 0x401) {
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 (_WIN32_WINNT >= 0x500) {
alias RasGetEapUserDataW RasGetEapUserData;
alias RasSetEapUserDataW RasSetEapUserData;
alias RasGetCustomAuthDataW RasGetCustomAuthData;
alias RasSetCustomAuthDataW RasSetCustomAuthData;
alias RasGetEapUserIdentityW RasGetEapUserIdentity;
alias RasFreeEapUserIdentityW RasFreeEapUserIdentity;
//}
} else { // !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 (_WIN32_WINNT >= 0x401) {
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 (_WIN32_WINNT >= 0x500) {
alias RasGetEapUserDataA RasGetEapUserData;
alias RasSetEapUserDataA RasSetEapUserData;
alias RasGetCustomAuthDataA RasGetCustomAuthData;
alias RasSetCustomAuthDataA RasSetCustomAuthData;
alias RasGetEapUserIdentityA RasGetEapUserIdentity;
alias RasFreeEapUserIdentityA RasFreeEapUserIdentity;
//}
} //#endif // !Unicode