WindowsXP-SP1/termsrv/cdmodem/inc/rasman.h
2020-09-30 16:53:49 +02:00

726 lines
18 KiB
C
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

//****************************************************************************
//
// Microsoft NT Remote Access Service
//
// Copyright 1992-93
//
//
// Revision History
//
//
// 5/26/92 Gurdeep Singh Pall Created
//
//
// Description: This file contains all structure and constant definitions for
// RAS Manager Component.
//
//****************************************************************************
#ifndef _RASMAN_
#define _RASMAN_
#include <windows.h>
#include <rassapi.h>
#define WM_RASAPICOMPLETE 0xCCCC // From the "user" window msg range
#define RASMAN_SERVICE_NAME "RASMAN"
#define MAX_MEDIA_NAME RASSAPI_MAX_MEDIA_NAME
#define MAX_PORT_NAME RASSAPI_MAX_PORT_NAME
#define MAX_DEVICE_NAME RASSAPI_MAX_DEVICE_NAME
#define MAX_DEVICETYPE_NAME RASSAPI_MAX_DEVICETYPE_NAME
#define MAX_PARAM_KEY_SIZE RASSAPI_MAX_PARAM_KEY_SIZE
#define MAX_PHONENUMBER_SIZE RASSAPI_MAX_PHONENUMBER_SIZE
#define MAX_USERKEY_SIZE 132
#define MAX_XPORT_NAME 128 // ??
#define MAX_IDENTIFIER_SIZE 32
#define MAX_STAT_NAME 32
#define MAX_CHALLENGE_SIZE 8
#define MAX_RESPONSE_SIZE 24
#define MAX_USERNAME_SIZE UNLEN
#define MAX_DOMAIN_SIZE DNLEN
#define MAX_PASSWORD_SIZE PWLEN
#define MAX_LAN_NETS 16
#define MAX_PROTOCOLS_PER_PORT 4
#define MAX_DLL_NAME_SIZE 8
#define MAX_ENTRYPOINT_NAME_SIZE 32
#define MAX_ARG_STRING_SIZE 32
#define MAX_ENTRYNAME_SIZE 256
#define MAX_CALLBACKNUMBER_SIZE MAX_PHONENUMBER_SIZE
#define MAX_PHONEENTRY_SIZE (MAX_PHONENUMBER_SIZE < MAX_ENTRYNAME_SIZE ? MAX_ENTRYNAME_SIZE : MAX_PHONENUMBER_SIZE)
#define INVALID_TAPI_ID 0xffffffff
typedef DWORD HPORT ;
typedef DWORD HBUNDLE ;
typedef DWORD HCONN;
enum RASMAN_STATUS {
OPEN = 0,
CLOSED = 1,
UNKNOWN = 2
} ;
typedef enum RASMAN_STATUS RASMAN_STATUS ;
enum RASMAN_USAGE {
CALL_IN = 0,
CALL_OUT = 1,
CALL_IN_OUT = 2,
CALL_NONE = 3
} ;
typedef enum RASMAN_USAGE RASMAN_USAGE ;
enum RAS_FORMAT {
Number = 0,
String = 1
} ;
typedef enum RAS_FORMAT RAS_FORMAT ;
union RAS_VALUE {
DWORD Number ;
struct {
DWORD Length ;
PCHAR Data ;
} String ;
} ;
typedef union RAS_VALUE RAS_VALUE ;
enum RASMAN_STATE {
CONNECTING = 0,
LISTENING = 1,
CONNECTED = 2,
DISCONNECTING = 3,
DISCONNECTED = 4,
LISTENCOMPLETED = 5,
} ;
typedef enum RASMAN_STATE RASMAN_STATE ;
enum RASMAN_DISCONNECT_REASON {
USER_REQUESTED = 0,
REMOTE_DISCONNECTION= 1,
HARDWARE_FAILURE = 2,
NOT_DISCONNECTED = 3
} ;
typedef enum RASMAN_DISCONNECT_REASON RASMAN_DISCONNECT_REASON ;
struct RAS_PARAMS {
CHAR P_Key [MAX_PARAM_KEY_SIZE] ;
RAS_FORMAT P_Type ;
BYTE P_Attributes ;
RAS_VALUE P_Value ;
} ;
typedef struct RAS_PARAMS RAS_PARAMS ;
struct RASMAN_PORT {
HPORT P_Handle ;
CHAR P_PortName [MAX_PORT_NAME] ;
RASMAN_STATUS P_Status ;
RASMAN_USAGE P_ConfiguredUsage ;
RASMAN_USAGE P_CurrentUsage ;
CHAR P_MediaName [MAX_MEDIA_NAME] ;
CHAR P_DeviceType[MAX_DEVICETYPE_NAME] ;
CHAR P_DeviceName[MAX_DEVICE_NAME+1] ;
DWORD P_LineDeviceId ; // only valid for TAPI devices
DWORD P_AddressId ; // only valid for TAPI devices
} ;
typedef struct RASMAN_PORT RASMAN_PORT ;
struct RASMAN_PORTINFO {
WORD PI_NumOfParams ;
RAS_PARAMS PI_Params[1] ;
} ;
typedef struct RASMAN_PORTINFO RASMAN_PORTINFO ;
struct RASMAN_DEVICE {
CHAR D_Name [MAX_DEVICE_NAME+1] ;
} ;
typedef struct RASMAN_DEVICE RASMAN_DEVICE ;
struct RASMAN_DEVICEINFO {
WORD DI_NumOfParams ;
RAS_PARAMS DI_Params[1] ;
} ;
typedef struct RASMAN_DEVICEINFO RASMAN_DEVICEINFO ;
enum RAS_PROTOCOLTYPE {
ASYBEUI = 0x80D5,
IPX = 0x8137,
IP = 0x0800,
ARP = 0x0806,
APPLETALK = 0x80F3,
XNS = 0x0600,
RASAUTH = 0x8FFF,
INVALID_TYPE= 0x2222
} ;
typedef enum RAS_PROTOCOLTYPE RAS_PROTOCOLTYPE ;
struct RASMAN_PROTOCOLINFO {
CHAR PI_XportName [MAX_XPORT_NAME] ;
RAS_PROTOCOLTYPE PI_Type ;
} ;
typedef struct RASMAN_PROTOCOLINFO RASMAN_PROTOCOLINFO ;
struct RASMAN_ROUTEINFO {
RAS_PROTOCOLTYPE RI_Type ;
BYTE RI_LanaNum ;
WCHAR RI_XportName [MAX_XPORT_NAME] ;
WCHAR RI_AdapterName [MAX_XPORT_NAME] ;
} ;
typedef struct RASMAN_ROUTEINFO RASMAN_ROUTEINFO ;
struct RAS_PROTOCOLS {
RASMAN_ROUTEINFO RP_ProtocolInfo[MAX_PROTOCOLS_PER_PORT] ;
} ;
typedef struct RAS_PROTOCOLS RAS_PROTOCOLS ;
struct RASMAN_INFO {
RASMAN_STATUS RI_PortStatus ;
RASMAN_STATE RI_ConnState ;
DWORD RI_LinkSpeed ;
DWORD RI_LastError ;
RASMAN_USAGE RI_CurrentUsage ;
CHAR RI_DeviceTypeConnecting [MAX_DEVICETYPE_NAME] ;
CHAR RI_DeviceConnecting [MAX_DEVICE_NAME+1] ;
RASMAN_DISCONNECT_REASON RI_DisconnectReason ;
DWORD RI_OwnershipFlag ;
DWORD RI_ConnectDuration ;
DWORD RI_BytesReceived ;
//
// If this port belongs to a connection, then
// the following fields are filled in.
//
CHAR RI_Phonebook[MAX_PATH+1];
CHAR RI_PhoneEntry[MAX_PHONEENTRY_SIZE+1];
HCONN RI_ConnectionHandle;
DWORD RI_SubEntry;
} ;
typedef struct RASMAN_INFO RASMAN_INFO ;
struct RAS_STATISTICS {
WORD S_NumOfStatistics ;
ULONG S_Statistics[1] ;
} ;
typedef struct RAS_STATISTICS RAS_STATISTICS ;
#define MAX_STATISTICS 14
#define MAX_STATISTICS_EX (MAX_STATISTICS * 2)
#define BYTES_XMITED 0 // Generic Stats
#define BYTES_RCVED 1
#define FRAMES_XMITED 2
#define FRAMES_RCVED 3
#define CRC_ERR 4 // Hardware Stats
#define TIMEOUT_ERR 5
#define ALIGNMENT_ERR 6
#define HARDWARE_OVERRUN_ERR 7
#define FRAMING_ERR 8
#define BUFFER_OVERRUN_ERR 9
#define BYTES_XMITED_UNCOMPRESSED 10 // Compression Stats
#define BYTES_RCVED_UNCOMPRESSED 11
#define BYTES_XMITED_COMPRESSED 12
#define BYTES_RCVED_COMPRESSED 13
#define MSTYPE_COMPRESSION 0x00000001
#define MSTYPE_ENCRYPTION_40 0x00000010
#define MSTYPE_ENCRYPTION_40F 0x00000020
#define MSTYPE_ENCRYPTION_128 0x00000040
#define MACTYPE_NT31RAS 254
#define MAX_SESSIONKEY_SIZE 8
#define MAX_COMPVALUE_SIZE 32
#define MAX_COMPOUI_SIZE 3
struct RAS_COMPRESSION_INFO {
UCHAR RCI_SessionKey[MAX_SESSIONKEY_SIZE]; // May be used for encryption, non-zero if supported.
ULONG RCI_MSCompressionType; // bit 0 = MPPPC, bit 5 = encryption.
UCHAR RCI_MacCompressionType; // 0=OUI, 1-253 = Public, 254 = NT31 RAS, 255=Not supported
WORD RCI_MacCompressionValueLength ;
union {
struct { // Proprietary: used for comp type 0
UCHAR RCI_CompOUI[MAX_COMPOUI_SIZE];
UCHAR RCI_CompSubType;
UCHAR RCI_CompValues[MAX_COMPVALUE_SIZE];
} RCI_Proprietary;
struct { // Public: used for comp type 1-254
UCHAR RCI_CompValues[MAX_COMPVALUE_SIZE];
} RCI_Public;
} RCI_Info ;
};
typedef struct RAS_COMPRESSION_INFO RAS_COMPRESSION_INFO;
struct PROTOCOL_CONFIG_INFO {
DWORD P_Length ;
BYTE P_Info[1] ;
} ;
typedef struct PROTOCOL_CONFIG_INFO PROTOCOL_CONFIG_INFO ;
struct RASMAN_PPPFEATURES {
DWORD MRU;
DWORD ACCM;
DWORD AuthProtocol;
DWORD MagicNumber;
BOOL PFC;
BOOL ACFC;
} ;
typedef struct RASMAN_PPPFEATURES RASMAN_PPPFEATURES ;
enum RAS_FRAMING {PPP, RAS, AUTODETECT, SLIP, SLIPCOMP, SLIPCOMPAUTO} ;
typedef enum RAS_FRAMING RAS_FRAMING ;
struct RAS_FRAMING_CAPABILITIES {
DWORD RFC_MaxFrameSize;
DWORD RFC_MaxReconstructedFrameSize;
DWORD RFC_FramingBits;
DWORD RFC_DesiredACCM;
} ;
typedef struct RAS_FRAMING_CAPABILITIES RAS_FRAMING_CAPABILITIES ;
struct RAS_FRAMING_INFO {
DWORD RFI_MaxSendFrameSize;
DWORD RFI_MaxRecvFrameSize;
DWORD RFI_MaxRSendFrameSize;
DWORD RFI_MaxRRecvFrameSize;
DWORD RFI_HeaderPadding;
DWORD RFI_TailPadding;
DWORD RFI_SendFramingBits;
DWORD RFI_RecvFramingBits;
DWORD RFI_SendCompressionBits;
DWORD RFI_RecvCompressionBits;
DWORD RFI_SendACCM;
DWORD RFI_RecvACCM;
} ;
typedef struct RAS_FRAMING_INFO RAS_FRAMING_INFO ;
// NDIS WAN Framing bits: used with RasPortGetFramingEx and RasPortSetFramingEx
// APIs.
//
#define OLD_RAS_FRAMING 0x00000001
#define RAS_COMPRESSION 0x00000002
#define PPP_MULTILINK_FRAMING 0x00000010
#define PPP_SHORT_SEQUENCE_HDR_FORMAT 0x00000020
#define PPP_FRAMING 0x00000100
#define PPP_COMPRESS_ADDRESS_CONTROL 0x00000200
#define PPP_COMPRESS_PROTOCOL_FIELD 0x00000400
#define PPP_ACCM_SUPPORTED 0x00000800
#define SLIP_FRAMING 0x00001000
#define SLIP_VJ_COMPRESSION 0x00002000
#define SLIP_VJ_AUTODETECT 0x00004000
#define MEDIA_NRZ_ENCODING 0x00010000
#define MEDIA_NRZI_ENCODING 0x00020000
#define MEDIA_NLPID 0x00040000
#define RFC_1356_FRAMING 0x00100000
#define RFC_1483_FRAMING 0x00200000
#define RFC_1490_FRAMING 0x00400000
#define SHIVA_FRAMING 0x01000000
// Defines for RAS_PROTOCOLCOMPRESSION
//
#define VJ_IP_COMPRESSION 0x002d
#define NO_PROTOCOL_COMPRESSION 0x0000
struct RAS_PROTOCOLCOMPRESSION {
union {
struct {
WORD RP_IPCompressionProtocol;
BYTE RP_MaxSlotID; // How many slots to allocate
BYTE RP_CompSlotID; // 1 = Slot ID was negotiated
} RP_IP ;
struct {
WORD RP_IPXCompressionProtocol;
} RP_IPX ;
} RP_ProtocolType ;
} ;
typedef struct RAS_PROTOCOLCOMPRESSION RAS_PROTOCOLCOMPRESSION ;
//
// Definitions for Ras{Get,Set}DialParams
//
// The dwMask values control/specify which fields
// of the RAS_DIALPARAMS are stored/retrieved.
//
// NOTE: these values have to match the RASCF_*
// values in ras.h.
//
#define DLPARAMS_MASK_USERNAME 0x00000001
#define DLPARAMS_MASK_PASSWORD 0x00000002
#define DLPARAMS_MASK_DOMAIN 0x00000004
#define DLPARAMS_MASK_PHONENUMBER 0x00000008
#define DLPARAMS_MASK_CALLBACKNUMBER 0x00000010
#define DLPARAMS_MASK_SUBENTRY 0x00000020
#define DLPARAMS_MASK_OLDSTYLE 0x80000000
typedef struct _RAS_DIALPARAMS {
DWORD DP_Uid;
WCHAR DP_PhoneNumber[MAX_PHONENUMBER_SIZE + 1];
WCHAR DP_CallbackNumber[MAX_CALLBACKNUMBER_SIZE + 1];
WCHAR DP_UserName[MAX_USERNAME_SIZE + 1];
WCHAR DP_Password[MAX_PASSWORD_SIZE + 1];
WCHAR DP_Domain[MAX_DOMAIN_SIZE + 1];
DWORD DP_SubEntry;
} RAS_DIALPARAMS, *PRAS_DIALPARAMS;
//
// Definitions for Ras{Get,Set}ConnectionParams
//
typedef struct _RAS_CONNECTIONPARAMS {
//
// Phonebook and entry name.
//
CHAR CP_Phonebook[MAX_PATH + 1];
CHAR CP_PhoneEntry[MAX_PHONEENTRY_SIZE + 1];
//
// Bandwidth-on-demand parameters
//
DWORD CP_DialExtraPercent;
DWORD CP_DialExtraSampleSeconds;
DWORD CP_HangUpExtraPercent;
DWORD CP_HangUpExtraSampleSeconds;
//
// Idle disconnect parameters
//
DWORD CP_IdleDisconnectSeconds;
//
// Redial on link failure flag
//
BOOL CP_RedialOnLinkFailure;
} RAS_CONNECTIONPARAMS, *PRAS_CONNECTIONPARAMS;
//
// Flags for RasAddNotification.
//
// Note: the NOTIF_* values must match the
// RASCN_* values in ras.h
//
#define NOTIF_CONNECT 0x00000001
#define NOTIF_DISCONNECT 0x00000002
#define NOTIF_BANDWIDTHADDED 0x00000004
#define NOTIF_BANDWIDTHREMOVED 0x00000008
//* RAS Manager entrypoint Prototypes
//
DWORD APIENTRY RasPortOpen(PCHAR, HPORT*, HANDLE);
DWORD APIENTRY RasPortClose(HPORT);
DWORD APIENTRY RasPortEnum(PBYTE, PWORD, PWORD);
DWORD APIENTRY RasPortGetInfo(HPORT, PBYTE, PWORD);
DWORD APIENTRY RasPortSetInfo(HPORT, RASMAN_PORTINFO*);
DWORD APIENTRY RasPortDisconnect(HPORT, HANDLE);
DWORD APIENTRY RasPortSend(HPORT, PBYTE, WORD);
DWORD APIENTRY RasPortReceive(HPORT, PBYTE, PWORD, DWORD, HANDLE);
DWORD APIENTRY RasPortListen(HPORT, DWORD, HANDLE);
DWORD APIENTRY RasPortConnectComplete(HPORT);
DWORD APIENTRY RasPortGetStatistics(HPORT, PBYTE, PWORD);
DWORD APIENTRY RasPortClearStatistics(HPORT);
DWORD APIENTRY RasDeviceEnum(PCHAR, PBYTE, PWORD, PWORD);
DWORD APIENTRY RasDeviceGetInfo(HPORT, PCHAR, PCHAR, PBYTE, PWORD);
DWORD APIENTRY RasDeviceSetInfo(HPORT, PCHAR, PCHAR, RASMAN_DEVICEINFO*);
DWORD APIENTRY RasDeviceConnect(HPORT, PCHAR, PCHAR, DWORD, HANDLE);
DWORD APIENTRY RasGetInfo(HPORT, RASMAN_INFO*);
DWORD APIENTRY RasGetInfoEx(RASMAN_INFO*, PWORD);
DWORD APIENTRY RasGetBuffer(PBYTE*, PWORD);
DWORD APIENTRY RasFreeBuffer(PBYTE);
DWORD APIENTRY RasProtocolEnum(PBYTE, PWORD, PWORD);
DWORD APIENTRY RasAllocateRoute(HPORT, RAS_PROTOCOLTYPE, BOOL, RASMAN_ROUTEINFO*);
DWORD APIENTRY RasActivateRoute(HPORT, RAS_PROTOCOLTYPE, RASMAN_ROUTEINFO*, PROTOCOL_CONFIG_INFO*);
DWORD APIENTRY RasActivateRouteEx(HPORT, RAS_PROTOCOLTYPE, DWORD, RASMAN_ROUTEINFO*, PROTOCOL_CONFIG_INFO*);
DWORD APIENTRY RasDeAllocateRoute(HPORT, RAS_PROTOCOLTYPE);
DWORD APIENTRY RasCompressionGetInfo(HPORT, RAS_COMPRESSION_INFO* Send, RAS_COMPRESSION_INFO* Recv);
DWORD APIENTRY RasCompressionSetInfo(HPORT, RAS_COMPRESSION_INFO* Send, RAS_COMPRESSION_INFO* Recv);
DWORD APIENTRY RasGetUserCredentials(PBYTE, PLUID, PWCHAR, PBYTE, PBYTE, PBYTE) ;
DWORD APIENTRY RasSetCachedCredentials( PCHAR, PCHAR, PCHAR ) ;
DWORD APIENTRY RasRequestNotification (HPORT, HANDLE) ;
DWORD APIENTRY RasPortCancelReceive (HPORT) ;
DWORD APIENTRY RasPortEnumProtocols (HPORT, RAS_PROTOCOLS*, PWORD) ;
DWORD APIENTRY RasEnumLanNets (DWORD *, UCHAR *) ;
DWORD APIENTRY RasPortSetFraming (HPORT, RAS_FRAMING, RASMAN_PPPFEATURES*, RASMAN_PPPFEATURES*) ;
DWORD APIENTRY RasPortRegisterSlip (HPORT, DWORD, WCHAR *, BOOL, WCHAR*, WCHAR*, WCHAR*, WCHAR*) ;
DWORD APIENTRY RasPortStoreUserData (HPORT, PBYTE, DWORD) ;
DWORD APIENTRY RasPortRetrieveUserData (HPORT, PBYTE, DWORD *) ;
DWORD APIENTRY RasPortGetFramingEx (HPORT, RAS_FRAMING_INFO *) ;
DWORD APIENTRY RasPortSetFramingEx (HPORT, RAS_FRAMING_INFO *) ;
DWORD APIENTRY RasPortGetProtocolCompression (HPORT, RAS_PROTOCOLTYPE, RAS_PROTOCOLCOMPRESSION *, RAS_PROTOCOLCOMPRESSION *) ;
DWORD APIENTRY RasPortSetProtocolCompression (HPORT, RAS_PROTOCOLTYPE, RAS_PROTOCOLCOMPRESSION *, RAS_PROTOCOLCOMPRESSION *) ;
DWORD APIENTRY RasGetFramingCapabilities (HPORT, RAS_FRAMING_CAPABILITIES*) ;
DWORD APIENTRY RasInitialize () ;
DWORD APIENTRY RasPortReserve (PCHAR, HPORT*) ;
DWORD APIENTRY RasPortFree (HPORT) ;
DWORD APIENTRY RasPortBundle( HPORT, HPORT );
DWORD APIENTRY RasPortGetBundledPort (HPORT oldport, HPORT *pnewport) ;
DWORD APIENTRY RasBundleGetPort (HBUNDLE hbundle, HPORT *phport) ;
DWORD APIENTRY RasPortGetBundle (HPORT hport, HBUNDLE *phbundle) ;
DWORD APIENTRY RasReferenceRasman (BOOL fAttach);
DWORD APIENTRY RasGetDialParams (DWORD dwUID, LPDWORD lpdwMask, PRAS_DIALPARAMS pDialParams);
DWORD APIENTRY RasSetDialParams (DWORD dwOldUID, DWORD dwMask, PRAS_DIALPARAMS pDialParams, BOOL fDelete);
DWORD APIENTRY RasCreateConnection (HCONN *hconn);
DWORD APIENTRY RasDestroyConnection (HCONN hconn);
DWORD APIENTRY RasConnectionEnum (HCONN *lphconn, LPDWORD lpdwcbConnections, LPDWORD lpdwcConnections);
DWORD APIENTRY RasAddConnectionPort (HCONN hconn, HPORT hport, DWORD dwSubEntry);
DWORD APIENTRY RasEnumConnectionPorts (HCONN hconn, RASMAN_PORT *pPorts, LPDWORD lpdwcbPorts, LPDWORD lpdwcPorts);
DWORD APIENTRY RasGetConnectionParams (HCONN hconn, PRAS_CONNECTIONPARAMS pConnectionParams);
DWORD APIENTRY RasSetConnectionParams (HCONN hconn, PRAS_CONNECTIONPARAMS pConnectionParams);
DWORD APIENTRY RasGetConnectionUserData (HPORT hconn, DWORD dwTag, PBYTE pBuf, LPDWORD lpdwcbBuf);
DWORD APIENTRY RasSetConnectionUserData (HPORT hconn, DWORD dwTag, PBYTE pBuf, DWORD dwcbBuf);
DWORD APIENTRY RasGetPortUserData (HPORT hport, DWORD dwTag, PBYTE pBuf, LPDWORD lpdwcbBuf);
DWORD APIENTRY RasSetPortUserData (HPORT hport, DWORD dwTag, PBYTE pBuf, DWORD dwcbBuf);
DWORD APIENTRY RasAddNotification (HCONN hconn, HANDLE hevent, DWORD dwfFlags);
DWORD APIENTRY RasSignalNewConnection(HCONN hconn);
DWORD APIENTRY RasSetDevConfig(HPORT hport, PCHAR devicetype, PBYTE config, DWORD size);
DWORD APIENTRY RasGetDevConfig(HPORT hport, PCHAR devicetype, PBYTE config, DWORD* size);
DWORD APIENTRY RasGetTimeSinceLastActivity(HPORT hport, LPDWORD lpdwTimeSinceLastActivity );
DWORD APIENTRY RasBundleGetStatistics(HPORT, PBYTE, PWORD);
DWORD APIENTRY RasBundleClearStatistics(HPORT);
DWORD _RasmanInit( LPDWORD pNumPorts );
VOID _RasmanEngine();
#endif