windows-nt/Source/XPSP1/NT/net/rras/netsh/ras/rasflag.c

1131 lines
25 KiB
C
Raw Normal View History

2020-09-26 03:20:57 -05:00
/*++
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;
}