1131 lines
25 KiB
C
1131 lines
25 KiB
C
/*++
|
|
|
|
Copyright (c) 1998 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
rasflag.c
|
|
|
|
Abstract:
|
|
|
|
Handlers for ras commands
|
|
|
|
Revision History:
|
|
|
|
pmay
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
static const WCHAR g_pszRegValServerFlags[] = L"ServerFlags";
|
|
static const WCHAR g_pszRegKeyServerFlags[] =
|
|
L"SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Parameters";
|
|
|
|
//
|
|
// Defines data that all server flag commands deal with
|
|
//
|
|
typedef struct _RASFLAG_DATA
|
|
{
|
|
HKEY hkFlags;
|
|
DWORD dwServerFlags;
|
|
|
|
} RASFLAG_DATA;
|
|
|
|
DWORD
|
|
RasflagOpen(
|
|
OUT PHANDLE phRasFlag);
|
|
|
|
DWORD
|
|
RasflagClose(
|
|
IN HANDLE hRasFlag);
|
|
|
|
DWORD
|
|
RasflagRead(
|
|
IN HANDLE hRasFlag,
|
|
OUT LPDWORD lpdwFlags);
|
|
|
|
DWORD
|
|
RasflagWrite(
|
|
IN HANDLE hRasFlag,
|
|
IN DWORD dwFlags);
|
|
|
|
DWORD
|
|
RasflagAuthtypeDump(
|
|
IN LPCWSTR pszToken,
|
|
IN BOOL bAdd);
|
|
|
|
DWORD
|
|
RasflagLinkDump(
|
|
IN LPCWSTR pszToken,
|
|
IN BOOL bAdd);
|
|
|
|
DWORD
|
|
RasflagMlinkDump(
|
|
IN LPCWSTR pszToken,
|
|
IN BOOL bAdd);
|
|
|
|
DWORD
|
|
RasflagOpen(
|
|
OUT PHANDLE phRasFlag)
|
|
{
|
|
RASFLAG_DATA* pData = NULL;
|
|
DWORD dwErr = NO_ERROR, dwType, dwSize;
|
|
|
|
do
|
|
{
|
|
// Alloc the return value
|
|
//
|
|
pData = (RASFLAG_DATA*) RutlAlloc(sizeof(RASFLAG_DATA), TRUE);
|
|
if (pData == NULL)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
dwErr = RegOpenKeyExW(
|
|
g_pServerInfo->hkMachine,
|
|
(PWCHAR) g_pszRegKeyServerFlags,
|
|
0,
|
|
KEY_READ | KEY_SET_VALUE,
|
|
&(pData->hkFlags));
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwType = REG_DWORD;
|
|
dwSize = sizeof(DWORD);
|
|
dwErr = RegQueryValueExW(
|
|
pData->hkFlags,
|
|
(PWCHAR) g_pszRegValServerFlags,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&(pData->dwServerFlags),
|
|
&dwSize);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Assign the return value
|
|
//
|
|
*phRasFlag = (HANDLE)pData;
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
RasflagClose(pData);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasflagClose(
|
|
IN HANDLE hRasFlag)
|
|
{
|
|
RASFLAG_DATA* pData = (RASFLAG_DATA*)hRasFlag;
|
|
|
|
if (pData)
|
|
{
|
|
if (pData->hkFlags)
|
|
{
|
|
RegCloseKey(pData->hkFlags);
|
|
}
|
|
RutlFree(pData);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RasflagRead(
|
|
IN HANDLE hRasFlag,
|
|
OUT LPDWORD lpdwFlags)
|
|
{
|
|
RASFLAG_DATA* pData = (RASFLAG_DATA*)hRasFlag;
|
|
|
|
*lpdwFlags = pData->dwServerFlags;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RasflagWrite(
|
|
IN HANDLE hRasFlag,
|
|
IN DWORD dwFlags)
|
|
{
|
|
RASFLAG_DATA* pData = (RASFLAG_DATA*)hRasFlag;
|
|
DWORD dwErr;
|
|
|
|
dwErr = RegSetValueEx(
|
|
pData->hkFlags,
|
|
(PWCHAR) g_pszRegValServerFlags,
|
|
0,
|
|
REG_DWORD,
|
|
(CONST BYTE*)&dwFlags,
|
|
sizeof(DWORD));
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
return dwErr;
|
|
}
|
|
|
|
pData->dwServerFlags = dwFlags;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Dumps domain related configuration
|
|
//
|
|
DWORD
|
|
RasflagDumpConfig(
|
|
IN HANDLE hFile
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwServerFlags = 0, i;
|
|
HANDLE hRasflag = NULL;
|
|
PWCHAR pszFlag = NULL, pszEnable = NULL, pszCmd = NULL;
|
|
BOOL bEnabled;
|
|
|
|
do
|
|
{
|
|
// Get the server flags info
|
|
//
|
|
dwErr = RasflagOpen( &hRasflag);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Read in the current flags
|
|
//
|
|
dwErr = RasflagRead(hRasflag, &dwServerFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Dump the command to set the authentication mode
|
|
//
|
|
{
|
|
PWCHAR pszToken;
|
|
|
|
if (dwServerFlags & PPPCFG_AllowNoAuthentication)
|
|
{
|
|
pszToken = TOKEN_BYPASS;
|
|
}
|
|
else if (dwServerFlags & PPPCFG_AllowNoAuthOnDCPorts)
|
|
{
|
|
pszToken = TOKEN_NODCC;
|
|
}
|
|
else
|
|
{
|
|
pszToken = TOKEN_STANDARD;
|
|
}
|
|
|
|
pszCmd = RutlAssignmentFromTokens(
|
|
g_hModule,
|
|
TOKEN_MODE,
|
|
pszToken);
|
|
if (pszCmd == NULL)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASFLAG_DUMP2,
|
|
DMP_RASFLAG_AUTHMODE_SET,
|
|
pszCmd);
|
|
|
|
RutlFree(pszCmd);
|
|
}
|
|
|
|
// Dump the commands to set the authentication type
|
|
//
|
|
{
|
|
RasflagAuthtypeDump(TOKEN_PAP, FALSE);
|
|
RasflagAuthtypeDump(TOKEN_SPAP, FALSE);
|
|
RasflagAuthtypeDump(TOKEN_MD5CHAP, FALSE);
|
|
RasflagAuthtypeDump(TOKEN_MSCHAP, FALSE);
|
|
RasflagAuthtypeDump(TOKEN_MSCHAP2, FALSE);
|
|
RasflagAuthtypeDump(TOKEN_EAP, FALSE);
|
|
|
|
if (dwServerFlags & PPPCFG_NegotiatePAP)
|
|
{
|
|
RasflagAuthtypeDump(TOKEN_PAP, TRUE);
|
|
}
|
|
if (dwServerFlags & PPPCFG_NegotiateSPAP)
|
|
{
|
|
RasflagAuthtypeDump(TOKEN_SPAP, TRUE);
|
|
}
|
|
if (dwServerFlags & PPPCFG_NegotiateMD5CHAP)
|
|
{
|
|
RasflagAuthtypeDump(TOKEN_MD5CHAP, TRUE);
|
|
}
|
|
if (dwServerFlags & PPPCFG_NegotiateMSCHAP)
|
|
{
|
|
RasflagAuthtypeDump(TOKEN_MSCHAP, TRUE);
|
|
}
|
|
if (dwServerFlags & PPPCFG_NegotiateStrongMSCHAP)
|
|
{
|
|
RasflagAuthtypeDump(TOKEN_MSCHAP2, TRUE);
|
|
}
|
|
if (dwServerFlags & PPPCFG_NegotiateEAP)
|
|
{
|
|
RasflagAuthtypeDump(TOKEN_EAP, TRUE);
|
|
}
|
|
}
|
|
|
|
// Dump the commands to set the link options
|
|
//
|
|
{
|
|
RasflagLinkDump(TOKEN_SWC, FALSE);
|
|
RasflagLinkDump(TOKEN_LCP, FALSE);
|
|
|
|
if (dwServerFlags & PPPCFG_UseSwCompression)
|
|
{
|
|
RasflagLinkDump(TOKEN_SWC, TRUE);
|
|
}
|
|
if (dwServerFlags & PPPCFG_UseLcpExtensions)
|
|
{
|
|
RasflagLinkDump(TOKEN_LCP, TRUE);
|
|
}
|
|
}
|
|
|
|
// Dump the commands to set the multilink options
|
|
//
|
|
{
|
|
RasflagMlinkDump(TOKEN_MULTI, FALSE);
|
|
RasflagMlinkDump(TOKEN_BACP, FALSE);
|
|
|
|
if (dwServerFlags & PPPCFG_NegotiateMultilink)
|
|
{
|
|
RasflagMlinkDump(TOKEN_MULTI, TRUE);
|
|
}
|
|
if (dwServerFlags & PPPCFG_NegotiateBacp)
|
|
{
|
|
RasflagMlinkDump(TOKEN_BACP, TRUE);
|
|
}
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (hRasflag)
|
|
{
|
|
RasflagClose(hRasflag);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagAuthmodeSet(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwFlag, dwServerFlags;
|
|
HANDLE hRasflag = NULL;
|
|
TOKEN_VALUE rgEnum[] =
|
|
{
|
|
{TOKEN_STANDARD, 0},
|
|
{TOKEN_NODCC, PPPCFG_AllowNoAuthOnDCPorts},
|
|
{TOKEN_BYPASS, PPPCFG_AllowNoAuthentication}
|
|
};
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_ENUM,
|
|
{TOKEN_MODE, TRUE, FALSE},
|
|
rgEnum,
|
|
sizeof(rgEnum)/sizeof(*rgEnum),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
do
|
|
{
|
|
// Parse
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
NULL,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Get arguments
|
|
//
|
|
dwFlag = RASMON_CMD_ARG_GetDword(&pArgs[0]);
|
|
|
|
// Read in the ras flags
|
|
//
|
|
dwErr = RasflagOpen(&hRasflag);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasflagRead(
|
|
hRasflag,
|
|
&dwServerFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Modify the server flags accordingly
|
|
//
|
|
switch (dwFlag)
|
|
{
|
|
case 0:
|
|
dwServerFlags &= ~PPPCFG_AllowNoAuthOnDCPorts;
|
|
dwServerFlags &= ~PPPCFG_AllowNoAuthentication;
|
|
break;
|
|
|
|
case PPPCFG_AllowNoAuthOnDCPorts:
|
|
dwServerFlags |= PPPCFG_AllowNoAuthOnDCPorts;
|
|
dwServerFlags &= ~PPPCFG_AllowNoAuthentication;
|
|
break;
|
|
|
|
case PPPCFG_AllowNoAuthentication:
|
|
dwServerFlags &= ~PPPCFG_AllowNoAuthOnDCPorts;
|
|
dwServerFlags |= PPPCFG_AllowNoAuthentication;
|
|
break;
|
|
}
|
|
|
|
dwErr = RasflagWrite(hRasflag, dwServerFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
//
|
|
{
|
|
if (hRasflag)
|
|
{
|
|
RasflagClose(hRasflag);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagAuthmodeShow(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwRasFlags, dwMessage;
|
|
HANDLE hRasflag = NULL;
|
|
|
|
do
|
|
{
|
|
// Make sure no arguments were passed in
|
|
//
|
|
if (dwArgCount - dwCurrentIndex != 0)
|
|
{
|
|
dwErr = ERROR_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
|
|
// Read in the ras flags
|
|
//
|
|
dwErr = RasflagOpen(&hRasflag);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasflagRead(
|
|
hRasflag,
|
|
&dwRasFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Determine the message to print
|
|
//
|
|
if (dwRasFlags & PPPCFG_AllowNoAuthentication)
|
|
{
|
|
dwMessage = MSG_RASFLAG_AUTHMODE_BYPASS;
|
|
}
|
|
else if (dwRasFlags & PPPCFG_AllowNoAuthOnDCPorts)
|
|
{
|
|
dwMessage = MSG_RASFLAG_AUTHMODE_NODCC;
|
|
}
|
|
else
|
|
{
|
|
dwMessage = MSG_RASFLAG_AUTHMODE_STANDARD;
|
|
}
|
|
|
|
DisplayMessage(g_hModule, dwMessage);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (hRasflag)
|
|
{
|
|
RasflagClose(hRasflag);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagAuthtypeAddDel(
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone,
|
|
IN BOOL bAdd
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwFlag, dwServerFlags;
|
|
HANDLE hRasflag = NULL;
|
|
TOKEN_VALUE rgEnum[] =
|
|
{
|
|
{TOKEN_PAP, PPPCFG_NegotiatePAP},
|
|
{TOKEN_SPAP, PPPCFG_NegotiateSPAP},
|
|
{TOKEN_MD5CHAP, PPPCFG_NegotiateMD5CHAP},
|
|
{TOKEN_MSCHAP, PPPCFG_NegotiateMSCHAP},
|
|
{TOKEN_MSCHAP2, PPPCFG_NegotiateStrongMSCHAP},
|
|
{TOKEN_EAP, PPPCFG_NegotiateEAP},
|
|
};
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_ENUM,
|
|
{TOKEN_TYPE, TRUE, FALSE},
|
|
rgEnum,
|
|
sizeof(rgEnum)/sizeof(*rgEnum),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
do
|
|
{
|
|
// Parse
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
NULL,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Get arguments
|
|
//
|
|
dwFlag = RASMON_CMD_ARG_GetDword(&pArgs[0]);
|
|
|
|
// Read in the ras flags
|
|
//
|
|
dwErr = RasflagOpen(&hRasflag);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasflagRead(
|
|
hRasflag,
|
|
&dwServerFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Modify the server flags accordingly
|
|
//
|
|
if (bAdd)
|
|
{
|
|
dwServerFlags |= dwFlag;
|
|
}
|
|
else
|
|
{
|
|
dwServerFlags &= ~dwFlag;
|
|
}
|
|
|
|
dwErr = RasflagWrite(hRasflag, dwServerFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
//
|
|
{
|
|
if (hRasflag)
|
|
{
|
|
RasflagClose(hRasflag);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagAuthtypeAdd(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
return HandleRasflagAuthtypeAddDel(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
TRUE);
|
|
}
|
|
|
|
|
|
DWORD
|
|
HandleRasflagAuthtypeDel(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
return HandleRasflagAuthtypeAddDel(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
FALSE);
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagAuthtypeShow(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwRasFlags, dwMessage;
|
|
HANDLE hRasflag = NULL;
|
|
|
|
do
|
|
{
|
|
// Make sure no arguments were passed in
|
|
//
|
|
if (dwArgCount - dwCurrentIndex != 0)
|
|
{
|
|
dwErr = ERROR_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
|
|
// Read in the ras flags
|
|
//
|
|
dwErr = RasflagOpen(&hRasflag);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasflagRead(
|
|
hRasflag,
|
|
&dwRasFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Display the header
|
|
//
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_AUTHTYPE_HEADER);
|
|
|
|
// Determine the types to print out
|
|
//
|
|
if (dwRasFlags & PPPCFG_NegotiatePAP)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_AUTHTYPE_PAP);
|
|
}
|
|
if (dwRasFlags & PPPCFG_NegotiateSPAP)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_AUTHTYPE_SPAP);
|
|
}
|
|
if (dwRasFlags & PPPCFG_NegotiateMD5CHAP)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_AUTHTYPE_MD5CHAP);
|
|
}
|
|
if (dwRasFlags & PPPCFG_NegotiateMSCHAP)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_AUTHTYPE_MSCHAP);
|
|
}
|
|
if (dwRasFlags & PPPCFG_NegotiateStrongMSCHAP)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_AUTHTYPE_MSCHAP2);
|
|
}
|
|
if (dwRasFlags & PPPCFG_NegotiateEAP)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_AUTHTYPE_EAP);
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (hRasflag)
|
|
{
|
|
RasflagClose(hRasflag);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagLinkAddDel(
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone,
|
|
IN BOOL bAdd
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwFlag, dwServerFlags;
|
|
HANDLE hRasflag = NULL;
|
|
TOKEN_VALUE rgEnum[] =
|
|
{
|
|
{TOKEN_SWC, PPPCFG_UseSwCompression},
|
|
{TOKEN_LCP, PPPCFG_UseLcpExtensions},
|
|
};
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_ENUM,
|
|
{TOKEN_TYPE, TRUE, FALSE},
|
|
rgEnum,
|
|
sizeof(rgEnum)/sizeof(*rgEnum),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
do
|
|
{
|
|
// Parse
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
NULL,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Get arguments
|
|
//
|
|
dwFlag = RASMON_CMD_ARG_GetDword(&pArgs[0]);
|
|
|
|
// Read in the ras flags
|
|
//
|
|
dwErr = RasflagOpen(&hRasflag);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasflagRead(
|
|
hRasflag,
|
|
&dwServerFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Modify the server flags accordingly
|
|
//
|
|
if (bAdd)
|
|
{
|
|
dwServerFlags |= dwFlag;
|
|
}
|
|
else
|
|
{
|
|
dwServerFlags &= ~dwFlag;
|
|
}
|
|
|
|
dwErr = RasflagWrite(hRasflag, dwServerFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
//
|
|
{
|
|
if (hRasflag)
|
|
{
|
|
RasflagClose(hRasflag);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagLinkAdd(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
return HandleRasflagLinkAddDel(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
TRUE);
|
|
}
|
|
|
|
|
|
DWORD
|
|
HandleRasflagLinkDel(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
return HandleRasflagLinkAddDel(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
FALSE);
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagLinkShow(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwRasFlags, dwMessage;
|
|
HANDLE hRasflag = NULL;
|
|
|
|
do
|
|
{
|
|
// Make sure no arguments were passed in
|
|
//
|
|
if (dwArgCount - dwCurrentIndex != 0)
|
|
{
|
|
dwErr = ERROR_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
|
|
// Read in the ras flags
|
|
//
|
|
dwErr = RasflagOpen(&hRasflag);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasflagRead(
|
|
hRasflag,
|
|
&dwRasFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Display the header
|
|
//
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_LINK_HEADER);
|
|
|
|
// Determine the types to print out
|
|
//
|
|
if (dwRasFlags & PPPCFG_UseSwCompression)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_LINK_SWC);
|
|
}
|
|
if (dwRasFlags & PPPCFG_UseLcpExtensions)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_LINK_LCP);
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (hRasflag)
|
|
{
|
|
RasflagClose(hRasflag);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagMlinkAddDel(
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone,
|
|
IN BOOL bAdd
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwFlag, dwServerFlags;
|
|
HANDLE hRasflag = NULL;
|
|
TOKEN_VALUE rgEnum[] =
|
|
{
|
|
{TOKEN_MULTI, PPPCFG_NegotiateMultilink},
|
|
{TOKEN_BACP, PPPCFG_NegotiateBacp},
|
|
};
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_ENUM,
|
|
{TOKEN_TYPE, TRUE, FALSE},
|
|
rgEnum,
|
|
sizeof(rgEnum)/sizeof(*rgEnum),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
do
|
|
{
|
|
// Parse
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
NULL,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Get arguments
|
|
//
|
|
dwFlag = RASMON_CMD_ARG_GetDword(&pArgs[0]);
|
|
|
|
// Read in the ras flags
|
|
//
|
|
dwErr = RasflagOpen(&hRasflag);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasflagRead(
|
|
hRasflag,
|
|
&dwServerFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Modify the server flags accordingly
|
|
//
|
|
if (bAdd)
|
|
{
|
|
dwServerFlags |= dwFlag;
|
|
}
|
|
else
|
|
{
|
|
dwServerFlags &= ~dwFlag;
|
|
}
|
|
|
|
dwErr = RasflagWrite(hRasflag, dwServerFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
//
|
|
{
|
|
if (hRasflag)
|
|
{
|
|
RasflagClose(hRasflag);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagMlinkAdd(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
return HandleRasflagMlinkAddDel(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
TRUE);
|
|
}
|
|
|
|
|
|
DWORD
|
|
HandleRasflagMlinkDel(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
return HandleRasflagMlinkAddDel(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
FALSE);
|
|
}
|
|
|
|
DWORD
|
|
HandleRasflagMlinkShow(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwRasFlags, dwMessage;
|
|
HANDLE hRasflag = NULL;
|
|
|
|
do
|
|
{
|
|
// Make sure no arguments were passed in
|
|
//
|
|
if (dwArgCount - dwCurrentIndex != 0)
|
|
{
|
|
dwErr = ERROR_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
|
|
// Read in the ras flags
|
|
//
|
|
dwErr = RasflagOpen(&hRasflag);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasflagRead(
|
|
hRasflag,
|
|
&dwRasFlags);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Display the header
|
|
//
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_MLINK_HEADER);
|
|
|
|
// Determine the types to print out
|
|
//
|
|
if (dwRasFlags & PPPCFG_NegotiateMultilink)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_MLINK_MULTI);
|
|
}
|
|
if (dwRasFlags & PPPCFG_NegotiateBacp)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASFLAG_MLINK_BACP);
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (hRasflag)
|
|
{
|
|
RasflagClose(hRasflag);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasflagAuthtypeDump(
|
|
IN LPCWSTR pszToken,
|
|
IN BOOL bAdd)
|
|
{
|
|
PWCHAR pszCmd = NULL;
|
|
|
|
pszCmd = RutlAssignmentFromTokens(
|
|
g_hModule,
|
|
TOKEN_TYPE,
|
|
pszToken);
|
|
if (pszCmd == NULL)
|
|
{
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASFLAG_DUMP2,
|
|
(bAdd) ? DMP_RASFLAG_AUTHTYPE_ADD : DMP_RASFLAG_AUTHTYPE_DEL,
|
|
pszCmd);
|
|
|
|
RutlFree(pszCmd);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RasflagLinkDump(
|
|
IN LPCWSTR pszToken,
|
|
IN BOOL bAdd)
|
|
{
|
|
PWCHAR pszCmd = NULL;
|
|
|
|
pszCmd = RutlAssignmentFromTokens(
|
|
g_hModule,
|
|
TOKEN_TYPE,
|
|
pszToken);
|
|
if (pszCmd == NULL)
|
|
{
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASFLAG_DUMP2,
|
|
(bAdd) ? DMP_RASFLAG_LINK_ADD : DMP_RASFLAG_LINK_DEL,
|
|
pszCmd);
|
|
|
|
RutlFree(pszCmd);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RasflagMlinkDump(
|
|
IN LPCWSTR pszToken,
|
|
IN BOOL bAdd)
|
|
{
|
|
PWCHAR pszCmd = NULL;
|
|
|
|
pszCmd = RutlAssignmentFromTokens(
|
|
g_hModule,
|
|
TOKEN_TYPE,
|
|
pszToken);
|
|
if (pszCmd == NULL)
|
|
{
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASFLAG_DUMP2,
|
|
(bAdd) ? DMP_RASFLAG_MLINK_ADD : DMP_RASFLAG_MLINK_DEL,
|
|
pszCmd);
|
|
|
|
RutlFree(pszCmd);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
|