able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rras/netsh/ras/rasaaaa.c

2372 lines
56 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
File: rasaaaa.h
The 'remoteaccess aaaa' sub context
3/2/99
*/
#include "precomp.h"
#include "rasaaaa.h"
#include <winsock2.h>
#include <ntlsa.h>
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
// The guid for this context
//
GUID g_RasAaaaGuid = RASAAAA_GUID;
static PWCHAR g_pszServer = NULL;
static DWORD g_dwBuild = 0;
// Stolen from snapin code
//
#define CCHRADIUSSERVER 13
#define PSZRADIUSSERVER L"RADIUSServer."
// The commands supported in this context
//
CMD_ENTRY g_RasAaaaAddCmdTable[] =
{
CREATE_CMD_ENTRY(RASAAAA_ADD_AUTHSERV, RasAaaaHandleAddAuthServ),
CREATE_CMD_ENTRY(RASAAAA_ADD_ACCTSERV, RasAaaaHandleAddAcctServ),
};
CMD_ENTRY g_RasAaaaDelCmdTable[] =
{
CREATE_CMD_ENTRY(RASAAAA_DEL_AUTHSERV, RasAaaaHandleDelAuthServ),
CREATE_CMD_ENTRY(RASAAAA_DEL_ACCTSERV, RasAaaaHandleDelAcctServ),
};
CMD_ENTRY g_RasAaaaSetCmdTable[] =
{
CREATE_CMD_ENTRY(RASAAAA_SET_AUTH, RasAaaaHandleSetAuth),
CREATE_CMD_ENTRY(RASAAAA_SET_ACCT, RasAaaaHandleSetAcct),
CREATE_CMD_ENTRY(RASAAAA_SET_AUTHSERV, RasAaaaHandleSetAuthServ),
CREATE_CMD_ENTRY(RASAAAA_SET_ACCTSERV, RasAaaaHandleSetAcctServ),
};
CMD_ENTRY g_RasAaaaShowCmdTable[] =
{
CREATE_CMD_ENTRY(RASAAAA_SHOW_AUTH, RasAaaaHandleShowAuth),
CREATE_CMD_ENTRY(RASAAAA_SHOW_ACCT, RasAaaaHandleShowAcct),
CREATE_CMD_ENTRY(RASAAAA_SHOW_AUTHSERV, RasAaaaHandleShowAuthServ),
CREATE_CMD_ENTRY(RASAAAA_SHOW_ACCTSERV, RasAaaaHandleShowAcctServ),
};
CMD_GROUP_ENTRY g_RasAaaaCmdGroups[] =
{
CREATE_CMD_GROUP_ENTRY(GROUP_SET, g_RasAaaaSetCmdTable),
CREATE_CMD_GROUP_ENTRY(GROUP_SHOW, g_RasAaaaShowCmdTable),
CREATE_CMD_GROUP_ENTRY(GROUP_ADD, g_RasAaaaAddCmdTable),
CREATE_CMD_GROUP_ENTRY(GROUP_DEL, g_RasAaaaDelCmdTable),
};
ULONG g_ulRasAaaaNumGroups = sizeof(g_RasAaaaCmdGroups)/sizeof(CMD_GROUP_ENTRY);
//
// Registry strings
//
WCHAR pszRegKeyAuth[] =
L"SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Authentication\\Providers";
WCHAR pszRegKeyAcct[] =
L"SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Accounting\\Providers";
WCHAR pszGuidWinAuth[] = L"{1AA7F841-C7F5-11D0-A376-00C04FC9DA04}";
WCHAR pszGuidRadAuth[] = L"{1AA7F83F-C7F5-11D0-A376-00C04FC9DA04}";
WCHAR pszGuidWinAcct[] = L"{1AA7F846-C7F5-11D0-A376-00C04FC9DA04}";
WCHAR pszGuidRadAcct[] = L"{1AA7F840-C7F5-11D0-A376-00C04FC9DA04}";
WCHAR pszRegValActiveProvider[] = L"ActiveProvider";
WCHAR pszRegKeyServers[] = L"Servers";
WCHAR pszRegValAuthPort[] = L"AuthPort";
WCHAR pszRegValAcctPort[] = L"AcctPort";
WCHAR pszRegValMessage[] = L"EnableAccountingOnOff";
WCHAR pszRegValScore[] = L"Score";
WCHAR pszRegValTimeout[] = L"Timeout";
WCHAR pszRegValSignature[] = L"SendSignature";
//
// Local definitions
//
#define RASAAAA_Auth 0x1
#define RASAAAA_Acct 0x2
#define RASAAAA_Windows 0x10
#define RASAAAA_Radius 0x20
#define RASAAAA_None 0x40
#define RASAAAA_F_Provider 0x1
#define RASAAAA_F_Create 0x2
//
// Structures representing auth/acct servers
//
typedef struct _AAAA_AUTH_SERVER
{
PWCHAR pszName;
PWCHAR pszSecret;
DWORD dwScore;
DWORD dwPort;
DWORD dwTimeout;
DWORD dwSignature;
} RASAAAA_AUTH_SERVER;
typedef struct _AAAA_ACCT_SERVER
{
PWCHAR pszName;
PWCHAR pszSecret;
DWORD dwScore;
DWORD dwPort;
DWORD dwTimeout;
DWORD dwMessages;
} RASAAAA_ACCT_SERVER;
typedef
DWORD
(* RASAAAA_SERVER_ENUM_CB)(
IN PVOID pvServer,
IN HANDLE hData);
typedef struct _AAAA_ENUM_DATA
{
DWORD dwType;
HANDLE hData;
RASAAAA_SERVER_ENUM_CB pEnum;
} RASAAAA_ENUM_DATA;
TOKEN_VALUE g_rgEnumEnableDisable[] =
{
{TOKEN_ENABLED, 1},
{TOKEN_DISABLED, 0}
};
RASMON_CMD_ARG g_pArgsAuth[] =
{
{
RASMONTR_CMD_TYPE_STRING,
{TOKEN_NAME, TRUE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_STRING,
{TOKEN_SECRET, FALSE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_DWORD,
{TOKEN_INITSCORE, FALSE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_DWORD,
{TOKEN_PORT, FALSE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_DWORD,
{TOKEN_TIMEOUT, FALSE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_ENUM,
{TOKEN_SIGNATURE, FALSE, FALSE},
g_rgEnumEnableDisable,
sizeof(g_rgEnumEnableDisable)/sizeof(*g_rgEnumEnableDisable),
NULL
}
};
RASMON_CMD_ARG g_pArgsAcct[] =
{
{
RASMONTR_CMD_TYPE_STRING,
{TOKEN_NAME, TRUE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_STRING,
{TOKEN_SECRET, FALSE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_DWORD,
{TOKEN_INITSCORE, FALSE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_DWORD,
{TOKEN_PORT, FALSE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_DWORD,
{TOKEN_TIMEOUT, FALSE, FALSE},
NULL,
0,
NULL
},
{
RASMONTR_CMD_TYPE_ENUM,
{TOKEN_MESSAGES, FALSE, FALSE},
g_rgEnumEnableDisable,
sizeof(g_rgEnumEnableDisable)/sizeof(*g_rgEnumEnableDisable),
NULL
}
};
#define g_dwArgsAuthCount (sizeof(g_pArgsAuth) / sizeof(*g_pArgsAuth))
#define g_dwArgsAcctCount (sizeof(g_pArgsAcct) / sizeof(*g_pArgsAcct))
//
// Local prototypes
//
DWORD
RasAaaaServerInit(
IN DWORD dwType,
OUT LPVOID lpvServer);
DWORD
RasAaaaServerCleanup(
IN DWORD dwType,
IN PVOID pvServer);
DWORD
RasAaaaServerAdd(
IN DWORD dwType,
IN PVOID pvServer);
DWORD
RasAaaaServerDelete(
IN DWORD dwType,
IN PVOID pvServer);
DWORD
RasAaaaServerRead(
IN DWORD dwType,
IN PVOID pvServer,
IN HKEY hkServer OPTIONAL);
DWORD
RasAaaaServerWrite(
IN DWORD dwType,
IN PVOID pvServer,
IN HKEY hkServer OPTIONAL,
IN BOOL bInitSecret);
DWORD
RasAaaaServerEnum(
IN DWORD dwType,
IN RASAAAA_SERVER_ENUM_CB pEnum,
IN HANDLE hData);
DWORD
RasAaaaServerKeyOpen(
IN DWORD dwType,
IN DWORD dwFlags,
OUT PHKEY phKey);
DWORD
RasAaaaServerSecretWrite(
IN LPCWSTR pszServer,
IN LPCWSTR pszSecret);
//
// Discovers the current provider
//
DWORD
RasAaaaProviderRead(
IN DWORD dwType,
OUT LPDWORD lpdwProvider)
{
DWORD dwErr = NO_ERROR;
HKEY hkProviders = NULL;
PWCHAR pszGuid = NULL;
do
{
// Show the authentication provider
//
dwErr = RasAaaaServerKeyOpen(
dwType,
RASAAAA_F_Provider,
&hkProviders);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegReadString(
hkProviders,
pszRegValActiveProvider,
&pszGuid);
BREAK_ON_DWERR(dwErr);
if (pszGuid == NULL)
{
dwErr = ERROR_CAN_NOT_COMPLETE;
break;
}
if (dwType == RASAAAA_Auth)
{
if (lstrcmpi(pszGuid, pszGuidRadAuth) == 0)
{
*lpdwProvider = RASAAAA_Radius;
}
else
{
*lpdwProvider = RASAAAA_Windows;
}
}
else
{
if (lstrcmpi(pszGuid, pszGuidRadAcct) == 0)
{
*lpdwProvider = RASAAAA_Radius;
}
else if (lstrcmpi(pszGuid, pszGuidWinAcct) == 0)
{
*lpdwProvider = RASAAAA_Windows;
}
else
{
*lpdwProvider = RASAAAA_None;
}
}
} while (FALSE);
// Cleanup
//
{
if (hkProviders)
{
RegCloseKey(hkProviders);
}
RutlFree(pszGuid);
}
return dwErr;
}
//
// Looks up the address of a server
//
DWORD
RasAaaaServerLookupAddress(
IN LPCWSTR pszServer,
OUT LPWSTR* ppszAddress)
{
DWORD dwErr = NO_ERROR, dwCount = 0, dwAddr;
struct hostent* pHost;
CHAR pszNameA[512];
WCHAR pszName[512];
do
{
// Convert the host name to ansi
//
dwCount = WideCharToMultiByte(
GetConsoleOutputCP(),
0,
pszServer,
-1,
pszNameA,
sizeof(pszNameA),
NULL,
NULL);
if (dwCount == 0)
{
dwErr = GetLastError();
break;
}
// Lookup the host
//
pHost = gethostbyname(pszNameA);
if (pHost == NULL)
{
*ppszAddress = RutlStrDup(pszServer);
if (*ppszAddress == NULL)
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
}
break;
}
// Convert the discovered address to unicode
//
dwAddr = *(PDWORD)(pHost->h_addr_list[0]);
dwCount = MultiByteToWideChar(
GetConsoleOutputCP(),
0,
inet_ntoa(*(PIN_ADDR)&dwAddr),
-1,
pszName,
sizeof(pszName) / sizeof(WCHAR));
if (dwCount == 0)
{
dwErr = GetLastError();
break;
}
*ppszAddress = RutlStrDup(pszName);
if (*ppszAddress == NULL)
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
}
} while (FALSE);
// Cleanup
{
}
return dwErr;
}
//
// Populates a server cb with defaults
//
DWORD
RasAaaaServerInit(
IN DWORD dwType,
OUT PVOID pvServer)
{
if (dwType == RASAAAA_Auth)
{
RASAAAA_AUTH_SERVER* pInfo = (RASAAAA_AUTH_SERVER*)pvServer;
pInfo->pszName = NULL;
pInfo->pszSecret = NULL;
pInfo->dwScore = 30;
pInfo->dwPort = 1812;
pInfo->dwTimeout = 5;
pInfo->dwSignature = 0;
}
else
{
RASAAAA_ACCT_SERVER* pInfo = (RASAAAA_ACCT_SERVER*)pvServer;
pInfo->pszName = NULL;
pInfo->pszSecret = NULL;
pInfo->dwScore = 30;
pInfo->dwPort = 1813;
pInfo->dwTimeout = 5;
pInfo->dwMessages = 0;
}
return NO_ERROR;
}
//
// Cleans up a server cb
//
DWORD
RasAaaaServerCleanup(
IN DWORD dwType,
IN PVOID pvServer)
{
if (dwType == RASAAAA_Auth)
{
RASAAAA_AUTH_SERVER* pInfo = (RASAAAA_AUTH_SERVER*)pvServer;
RutlFree(pInfo->pszName);
RutlFree(pInfo->pszSecret);
}
else
{
RASAAAA_ACCT_SERVER* pInfo = (RASAAAA_ACCT_SERVER*)pvServer;
RutlFree(pInfo->pszName);
RutlFree(pInfo->pszSecret);
}
return NO_ERROR;
}
//
// Adds a server
//
DWORD
RasAaaaServerAdd(
IN DWORD dwType,
IN PVOID pvServer)
{
DWORD dwErr = NO_ERROR, dwDisposition;
HKEY hkServers = NULL, hkKey = NULL;
do
{
dwErr = RasAaaaServerKeyOpen(
dwType,
RASAAAA_F_Create,
&hkServers);
BREAK_ON_DWERR(dwErr);
// Create the new key
//
dwErr = RegCreateKeyExW(
hkServers,
*((PWCHAR*)pvServer),
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hkKey,
&dwDisposition);
BREAK_ON_DWERR(dwErr);
if (dwDisposition == REG_OPENED_EXISTING_KEY)
{
dwErr = ERROR_ALREADY_EXISTS;
break;
}
dwErr = RasAaaaServerWrite(dwType, pvServer, hkKey, TRUE);
BREAK_ON_DWERR(dwErr);
} while (FALSE);
// Cleanup
//
{
if (hkServers)
{
RegCloseKey(hkServers);
}
if (hkKey)
{
RegCloseKey(hkKey);
}
}
return dwErr;
}
DWORD
RasAaaaServerDelete(
IN DWORD dwType,
IN PVOID pvServer)
{
DWORD dwErr = NO_ERROR;
HKEY hkServers = NULL;
do
{
dwErr = RasAaaaServerKeyOpen(
dwType,
0,
&hkServers);
BREAK_ON_DWERR(dwErr);
dwErr = RegDeleteKey(hkServers, *(PWCHAR*)pvServer);
BREAK_ON_DWERR(dwErr);
// Cleanup the shared secret
//
RasAaaaServerSecretWrite(*(PWCHAR*)pvServer, NULL);
} while (FALSE);
// Cleanup
{
if (hkServers)
{
RegCloseKey(hkServers);
}
}
return dwErr;
}
//
// Callback to an enumeration function that deletes the given
// authentication server
//
DWORD
RasAaaaServerDeleteAuthCb(
IN PVOID pvServer,
IN HANDLE hData)
{
return RasAaaaServerDelete(RASAAAA_Auth, pvServer);
}
//
// Callback to an enumeration function that deletes the given
// accounting server
//
DWORD
RasAaaaServerDeleteAcctCb(
IN PVOID pvServer,
IN HANDLE hData)
{
return RasAaaaServerDelete(RASAAAA_Acct, pvServer);
}
//
// Read server info
//
DWORD
RasAaaaServerRead(
IN DWORD dwType,
IN PVOID pvServer,
IN HKEY hkServer OPTIONAL)
{
DWORD dwErr = NO_ERROR;
HKEY hkServers = NULL, hkKey = NULL;
do
{
if (hkServer == NULL)
{
dwErr = RasAaaaServerKeyOpen(
dwType,
0,
&hkServers);
BREAK_ON_DWERR(dwErr);
dwErr = RegOpenKeyEx(
hkServers,
*(PWCHAR*)pvServer,
0,
KEY_ALL_ACCESS,
&hkKey);
BREAK_ON_DWERR(dwErr);
}
else
{
hkKey = hkServer;
}
if (dwType == RASAAAA_Auth)
{
RASAAAA_AUTH_SERVER* pInfo = (RASAAAA_AUTH_SERVER*)pvServer;
dwErr = RutlRegReadDword(
hkKey,
pszRegValScore,
&pInfo->dwScore);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegReadDword(
hkKey,
pszRegValAuthPort,
&pInfo->dwPort);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegReadDword(
hkKey,
pszRegValTimeout,
&pInfo->dwTimeout);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegReadDword(
hkKey,
pszRegValSignature,
&pInfo->dwSignature);
BREAK_ON_DWERR(dwErr);
}
else
{
RASAAAA_ACCT_SERVER* pInfo = (RASAAAA_ACCT_SERVER*)pvServer;
dwErr = RutlRegReadDword(
hkKey,
pszRegValScore,
&pInfo->dwScore);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegReadDword(
hkKey,
pszRegValAcctPort,
&pInfo->dwPort);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegReadDword(
hkKey,
pszRegValTimeout,
&pInfo->dwTimeout);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegReadDword(
hkKey,
pszRegValMessage,
&pInfo->dwMessages);
BREAK_ON_DWERR(dwErr);
}
} while (FALSE);
// Cleanup
//
{
if (hkServers)
{
RegCloseKey(hkServers);
}
if (hkKey && hkServer == NULL)
{
RegCloseKey(hkKey);
}
}
return dwErr;
}
//
// Write server info
//
DWORD
RasAaaaServerWrite(
IN DWORD dwType,
IN PVOID pvServer,
IN HKEY hkServer, OPTIONAL
IN BOOL bInitSecret)
{
DWORD dwErr = NO_ERROR;
HKEY hkServers = NULL, hkKey = NULL;
do
{
if (hkServer == NULL)
{
dwErr = RasAaaaServerKeyOpen(
dwType,
0,
&hkServers);
BREAK_ON_DWERR(dwErr);
dwErr = RegOpenKeyEx(
hkServers,
*(PWCHAR*)pvServer,
0,
KEY_ALL_ACCESS,
&hkKey);
BREAK_ON_DWERR(dwErr);
}
else
{
hkKey = hkServer;
}
if (dwType == RASAAAA_Auth)
{
RASAAAA_AUTH_SERVER* pInfo = (RASAAAA_AUTH_SERVER*)pvServer;
dwErr = RutlRegWriteDword(
hkKey,
pszRegValScore,
pInfo->dwScore);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegWriteDword(
hkKey,
pszRegValAuthPort,
pInfo->dwPort);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegWriteDword(
hkKey,
pszRegValTimeout,
pInfo->dwTimeout);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegWriteDword(
hkKey,
pszRegValSignature,
pInfo->dwSignature);
BREAK_ON_DWERR(dwErr);
if (pInfo->pszSecret)
{
dwErr = RasAaaaServerSecretWrite(
pInfo->pszName,
pInfo->pszSecret);
BREAK_ON_DWERR(dwErr);
}
else if (bInitSecret)
{
dwErr = RasAaaaServerSecretWrite(
pInfo->pszName,
L"");
BREAK_ON_DWERR(dwErr);
}
}
else
{
RASAAAA_ACCT_SERVER* pInfo = (RASAAAA_ACCT_SERVER*)pvServer;
dwErr = RutlRegWriteDword(
hkKey,
pszRegValScore,
pInfo->dwScore);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegWriteDword(
hkKey,
pszRegValAcctPort,
pInfo->dwPort);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegWriteDword(
hkKey,
pszRegValTimeout,
pInfo->dwTimeout);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegWriteDword(
hkKey,
pszRegValMessage,
pInfo->dwMessages);
BREAK_ON_DWERR(dwErr);
if (pInfo->pszSecret)
{
dwErr = RasAaaaServerSecretWrite(
pInfo->pszName,
pInfo->pszSecret);
BREAK_ON_DWERR(dwErr);
}
else if (bInitSecret)
{
dwErr = RasAaaaServerSecretWrite(
pInfo->pszName,
L"");
BREAK_ON_DWERR(dwErr);
}
}
} while (FALSE);
// Cleanup
{
if (hkServers)
{
RegCloseKey(hkServers);
}
if (hkKey && hkServer == NULL)
{
RegCloseKey(hkKey);
}
}
return dwErr;
}
//
// Callback function for registry enumerator
//
DWORD
RasAaaaServerEnumCb(
IN LPCWSTR pszName,
IN HKEY hKey,
IN HANDLE hData)
{
RASAAAA_ENUM_DATA* pData = (RASAAAA_ENUM_DATA*)hData;
RASAAAA_AUTH_SERVER AuthServer;
RASAAAA_ACCT_SERVER AcctServer;
DWORD dwErr = NO_ERROR;
ZeroMemory(&AuthServer, sizeof(AuthServer));
ZeroMemory(&AcctServer, sizeof(AcctServer));
do
{
if (pData->dwType == RASAAAA_Auth)
{
AuthServer.pszName = RutlStrDup(pszName);
dwErr = RasAaaaServerRead(
pData->dwType,
(PVOID)&AuthServer,
hKey);
BREAK_ON_DWERR(dwErr);
dwErr = pData->pEnum((PVOID)&AuthServer, pData->hData);
BREAK_ON_DWERR(dwErr);
}
else
{
AcctServer.pszName = RutlStrDup(pszName);
dwErr = RasAaaaServerRead(
pData->dwType,
(PVOID)&AcctServer,
hKey);
BREAK_ON_DWERR(dwErr);
dwErr = pData->pEnum((PVOID)&AcctServer, pData->hData);
BREAK_ON_DWERR(dwErr);
}
} while (FALSE);
// Cleanup
//
{
RasAaaaServerCleanup(
pData->dwType,
(pData->dwType == RASAAAA_Auth) ?
(PVOID)&AuthServer :
(PVOID)&AcctServer);
}
return dwErr;
}
//
// Enumerates the servers
//
DWORD
RasAaaaServerEnum(
IN DWORD dwType,
IN RASAAAA_SERVER_ENUM_CB pEnum,
IN HANDLE hData)
{
DWORD dwErr = NO_ERROR;
HKEY hkServers = NULL;
RASAAAA_ENUM_DATA EnumData;
do
{
ZeroMemory(&EnumData, sizeof(EnumData));
dwErr = RasAaaaServerKeyOpen(
dwType,
0,
&hkServers);
if (dwErr == ERROR_FILE_NOT_FOUND)
{
dwErr = NO_ERROR;
break;
}
BREAK_ON_DWERR(dwErr);
EnumData.dwType = dwType;
EnumData.pEnum = pEnum;
EnumData.hData = hData;
dwErr = RutlRegEnumKeys(
hkServers,
RasAaaaServerEnumCb,
(HANDLE)&EnumData);
BREAK_ON_DWERR(dwErr);
} while (FALSE);
// Cleanup
//
{
if (hkServers)
{
RegCloseKey(hkServers);
}
}
return dwErr;
}
//
// Opens the appropriate registry key
//
DWORD
RasAaaaServerKeyOpen(
IN DWORD dwType,
IN DWORD dwFlags,
OUT PHKEY phKey)
{
HKEY hkRoot = NULL, hkProvider = NULL;
DWORD dwErr = NO_ERROR;
do
{
dwErr = RegOpenKeyEx(
g_pServerInfo->hkMachine,
(dwType == RASAAAA_Auth) ? pszRegKeyAuth : pszRegKeyAcct,
0,
KEY_ALL_ACCESS,
&hkRoot);
BREAK_ON_DWERR(dwErr);
if (dwFlags & RASAAAA_F_Provider)
{
*phKey = hkRoot;
break;
}
dwErr = RegOpenKeyEx(
hkRoot,
(dwType == RASAAAA_Auth) ? pszGuidRadAuth : pszGuidRadAcct,
0,
KEY_ALL_ACCESS,
&hkProvider);
BREAK_ON_DWERR(dwErr);
if (dwFlags & RASAAAA_F_Create)
{
DWORD dwDisposition;
dwErr = RegCreateKeyExW(
hkProvider,
pszRegKeyServers,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
phKey,
&dwDisposition);
BREAK_ON_DWERR(dwErr);
}
else
{
dwErr = RegOpenKeyExW(
hkProvider,
pszRegKeyServers,
0,
KEY_ALL_ACCESS,
phKey);
BREAK_ON_DWERR(dwErr);
}
} while (FALSE);
// Cleanup
{
if (hkRoot && !(dwFlags & RASAAAA_F_Provider))
{
RegCloseKey(hkRoot);
}
if (hkProvider)
{
RegCloseKey(hkProvider);
}
if (dwErr != NO_ERROR)
{
if (*phKey)
{
RegCloseKey(*phKey);
}
*phKey = NULL;
}
}
return dwErr;
}
//
// Saves a shared secret
//
DWORD
RasAaaaServerSecretWrite(
IN LPCWSTR pszRadiusServerName,
IN LPCWSTR pszSecret)
{
LSA_HANDLE hLSA = NULL;
NTSTATUS ntStatus;
LSA_OBJECT_ATTRIBUTES objectAttributes;
LSA_UNICODE_STRING LSAPrivData, LSAPrivDataDesc;
TCHAR tszPrivData[MAX_PATH+1],
tszPrivDataDesc[MAX_PATH+CCHRADIUSSERVER+1];
TCHAR * ptszTemp;
PUNICODE_STRING pSystem;
UNICODE_STRING uszSystemName;
pSystem = NULL;
InitializeObjectAttributes(&objectAttributes, NULL, 0, NULL, NULL);
ntStatus = LsaOpenPolicy(
pSystem,
&objectAttributes,
POLICY_ALL_ACCESS,
&hLSA);
if ( !NT_SUCCESS( ntStatus) )
{
return( RtlNtStatusToDosError( ntStatus ) );
}
ZeroMemory(tszPrivDataDesc, sizeof(tszPrivDataDesc));
lstrcpy(tszPrivDataDesc, PSZRADIUSSERVER);
lstrcpyn(tszPrivDataDesc + CCHRADIUSSERVER, pszRadiusServerName, MAX_PATH);
LSAPrivDataDesc.Length = (USHORT)((lstrlen(tszPrivDataDesc) + 1) * sizeof(TCHAR));
LSAPrivDataDesc.MaximumLength = sizeof(tszPrivDataDesc);
LSAPrivDataDesc.Buffer = tszPrivDataDesc;
ZeroMemory(tszPrivData, sizeof(tszPrivData));
if (pszSecret)
{
lstrcpyn(tszPrivData, pszSecret, MAX_PATH);
LSAPrivData.Length = (USHORT)(lstrlen(tszPrivData) * sizeof(TCHAR));
LSAPrivData.MaximumLength = sizeof(tszPrivData);
LSAPrivData.Buffer = tszPrivData;
}
else
{
LSAPrivData.Length = 0;
LSAPrivData.MaximumLength = 0;
LSAPrivData.Buffer = NULL;
}
ntStatus = LsaStorePrivateData(hLSA, &LSAPrivDataDesc, &LSAPrivData);
ZeroMemory( tszPrivData, sizeof( tszPrivData ) );
LsaClose(hLSA);
return( RtlNtStatusToDosError( ntStatus ) );
}
//
// Displays the given server
//
DWORD
RasAaaaServerAuthShow(
IN PVOID pvServer,
IN HANDLE hData)
{
DWORD dwErr = NO_ERROR;
RASAAAA_AUTH_SERVER* pServer = (RASAAAA_AUTH_SERVER*)pvServer;
PWCHAR pszAddress = NULL;
BOOL* pDumpFmt = (BOOL*)hData;
PWCHAR pszPort = NULL, pszScore = NULL, pszTimeout = NULL,
pszName = NULL, pszSig = NULL;
do
{
if (!pDumpFmt || *pDumpFmt == FALSE)
{
// Lookup the address
//
dwErr = RasAaaaServerLookupAddress(pServer->pszName, &pszAddress);
BREAK_ON_DWERR(dwErr);
DisplayMessage(
g_hModule,
MSG_RASAAAA_SHOW_AUTHSERV,
pServer->pszName,
pszAddress,
pServer->dwPort,
pServer->dwScore,
pServer->dwTimeout,
(pServer->dwSignature) ? TOKEN_ENABLED : TOKEN_DISABLED);
}
else
{
// Make assignment strings
//
pszPort = RutlAssignmentFromTokenAndDword(
g_hModule,
TOKEN_PORT,
pServer->dwPort,
10);
pszScore = RutlAssignmentFromTokenAndDword(
g_hModule,
TOKEN_INITSCORE,
pServer->dwScore,
10);
pszTimeout = RutlAssignmentFromTokenAndDword(
g_hModule,
TOKEN_TIMEOUT,
pServer->dwTimeout,
10);
pszName = RutlAssignmentFromTokens(
g_hModule,
TOKEN_NAME,
pServer->pszName);
pszSig = RutlAssignmentFromTokens(
g_hModule,
TOKEN_SIGNATURE,
(pServer->dwSignature) ?
TOKEN_ENABLED :
TOKEN_DISABLED);
if (!pszPort || !pszScore || !pszTimeout || !pszName || !pszSig)
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
break;
}
// Display the command
//
DisplayMessage(
g_hModule,
MSG_RASAAAA_CMD5,
DMP_RASAAAA_ADD_AUTHSERV,
pszName,
pszPort,
pszScore,
pszTimeout,
pszSig);
}
} while (FALSE);
// Cleanup
{
RutlFree(pszAddress);
RutlFree(pszName);
RutlFree(pszPort);
RutlFree(pszScore);
RutlFree(pszTimeout);
RutlFree(pszSig);
}
return dwErr;
}
//
// Displays the given server
//
DWORD
RasAaaaServerAcctShow(
IN PVOID pvServer,
IN HANDLE hData)
{
DWORD dwErr = NO_ERROR;
RASAAAA_ACCT_SERVER* pServer = (RASAAAA_ACCT_SERVER*)pvServer;
PWCHAR pszAddress = NULL;
PWCHAR pszPort = NULL, pszScore = NULL, pszTimeout = NULL,
pszName = NULL, pszMsg = NULL;
BOOL* pDumpFmt = (BOOL*)hData;
do
{
if (!pDumpFmt || *pDumpFmt == FALSE)
{
// Lookup the address
//
dwErr = RasAaaaServerLookupAddress(pServer->pszName, &pszAddress);
BREAK_ON_DWERR(dwErr);
DisplayMessage(
g_hModule,
MSG_RASAAAA_SHOW_AUTHSERV,
pServer->pszName,
pszAddress,
pServer->dwPort,
pServer->dwScore,
pServer->dwTimeout,
(pServer->dwMessages) ? TOKEN_ENABLED : TOKEN_DISABLED);
}
else
{
// Make assignment strings
//
pszPort = RutlAssignmentFromTokenAndDword(
g_hModule,
TOKEN_PORT,
pServer->dwPort,
10);
pszScore = RutlAssignmentFromTokenAndDword(
g_hModule,
TOKEN_INITSCORE,
pServer->dwScore,
10);
pszTimeout = RutlAssignmentFromTokenAndDword(
g_hModule,
TOKEN_TIMEOUT,
pServer->dwTimeout,
10);
pszName = RutlAssignmentFromTokens(
g_hModule,
TOKEN_NAME,
pServer->pszName);
pszMsg = RutlAssignmentFromTokens(
g_hModule,
TOKEN_MESSAGES,
(pServer->dwMessages) ?
TOKEN_ENABLED :
TOKEN_DISABLED);
if (!pszPort || !pszScore || !pszTimeout || !pszName || !pszMsg)
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
break;
}
// Display the command
//
DisplayMessage(
g_hModule,
MSG_RASAAAA_CMD5,
DMP_RASAAAA_ADD_ACCTSERV,
pszName,
pszPort,
pszScore,
pszTimeout,
pszMsg);
}
} while (FALSE);
// Cleanup
{
RutlFree(pszAddress);
RutlFree(pszName);
RutlFree(pszPort);
RutlFree(pszScore);
RutlFree(pszTimeout);
RutlFree(pszMsg);
}
return dwErr;
}
//
// Entry called by rasmontr to register this context
//
DWORD
WINAPI
RasAaaaStartHelper(
IN CONST GUID *pguidParent,
IN DWORD dwVersion)
{
DWORD dwErr = NO_ERROR;
NS_CONTEXT_ATTRIBUTES attMyAttributes;
// Initialize
//
ZeroMemory(&attMyAttributes, sizeof(attMyAttributes));
attMyAttributes.pwszContext = L"aaaa";
attMyAttributes.guidHelper = g_RasAaaaGuid;
attMyAttributes.dwVersion = RASAAAA_VERSION;
attMyAttributes.dwFlags = 0;
attMyAttributes.ulNumTopCmds= 0;
attMyAttributes.pTopCmds = NULL;
attMyAttributes.ulNumGroups = g_ulRasAaaaNumGroups;
attMyAttributes.pCmdGroups = (CMD_GROUP_ENTRY (*)[])&g_RasAaaaCmdGroups;
attMyAttributes.pfnDumpFn = RasAaaaDump;
dwErr = RegisterContext( &attMyAttributes );
return dwErr;
}
DWORD
WINAPI
RasAaaaDump(
IN LPCWSTR pwszRouter,
IN OUT LPWSTR *ppwcArguments,
IN DWORD dwArgCount,
IN LPCVOID pvData
)
{
DWORD dwErr = NO_ERROR, dwProvider;
PWCHAR pszCmd = NULL, pszToken = NULL;
BOOL bDumpFmt;
// Dump the header
//
DisplayMessage(g_hModule, MSG_RASAAAA_SCRIPTHEADER);
DisplayMessageT(DMP_RASAAAA_PUSHD);
do
{
// Dump the commands to set the correct authentication and
// accounting providers
//
dwErr = RasAaaaProviderRead(RASAAAA_Auth, &dwProvider);
BREAK_ON_DWERR(dwErr);
pszCmd = RutlAssignmentFromTokens(
g_hModule,
TOKEN_PROVIDER,
(dwProvider == RASAAAA_Windows) ?
TOKEN_WINDOWS :
TOKEN_RADIUS);
if (pszCmd == NULL)
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
break;
}
DisplayMessage(
g_hModule,
MSG_RASAAAA_CMD1,
DMP_RASAAAA_SET_AUTH,
pszCmd);
RutlFree(pszCmd);
dwErr = RasAaaaProviderRead(RASAAAA_Acct, &dwProvider);
BREAK_ON_DWERR(dwErr);
if (dwProvider == RASAAAA_Windows)
{
pszToken = (PWCHAR)TOKEN_WINDOWS;
}
else if (dwProvider == RASAAAA_Radius)
{
pszToken = (PWCHAR)TOKEN_RADIUS;
}
else
{
pszToken = (PWCHAR)TOKEN_NONE;
}
pszCmd = RutlAssignmentFromTokens(
g_hModule,
TOKEN_PROVIDER,
pszToken);
if (pszCmd == NULL)
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
break;
}
DisplayMessage(
g_hModule,
MSG_RASAAAA_CMD1,
DMP_RASAAAA_SET_ACCT,
pszCmd);
RutlFree(pszCmd);
DisplayMessageT(MSG_NEWLINE);
// Dump the commands to delete all of the current servers
//
pszCmd = RutlAssignmentFromTokens(
g_hModule,
TOKEN_NAME,
TOKEN_RASAAAA_ALLSERVERS);
if (pszCmd == NULL)
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
break;
}
DisplayMessage(
g_hModule,
MSG_RASAAAA_CMD1,
DMP_RASAAAA_DEL_AUTHSERV,
pszCmd);
DisplayMessage(
g_hModule,
MSG_RASAAAA_CMD1,
DMP_RASAAAA_DEL_ACCTSERV,
pszCmd);
RutlFree(pszCmd);
DisplayMessageT(MSG_NEWLINE);
// Dump commands to add all of the current auth servers
//
bDumpFmt = TRUE;
dwErr = RasAaaaServerEnum(
RASAAAA_Auth,
RasAaaaServerAuthShow,
(HANDLE)&bDumpFmt);
BREAK_ON_DWERR(dwErr);
DisplayMessageT(MSG_NEWLINE);
// Dump commands to add all of the accouting servers
//
dwErr = RasAaaaServerEnum(
RASAAAA_Acct,
RasAaaaServerAcctShow,
(HANDLE)&bDumpFmt);
BREAK_ON_DWERR(dwErr);
} while (FALSE);
// Dump the footer
DisplayMessageT(DMP_RASAAAA_POPD);
DisplayMessage(g_hModule, MSG_RASAAAA_SCRIPTFOOTER);
// Cleanup
{
}
return dwErr;
}
DWORD
RasAaaaHandleAddAuthServ(
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;
RASAAAA_AUTH_SERVER Server;
RASMON_CMD_ARG pArgs[g_dwArgsAuthCount];
// Initialize
CopyMemory(pArgs, g_pArgsAuth, sizeof(g_pArgsAuth));
do
{
dwErr = RasAaaaServerInit(RASAAAA_Auth, (PVOID)&Server);
BREAK_ON_DWERR(dwErr);
// Parse the command line
//
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
Server.pszName = RASMON_CMD_ARG_GetPsz(pArgs + 0);
Server.pszSecret = RASMON_CMD_ARG_GetPsz(pArgs + 1);
if (RASMON_CMD_ARG_Present(pArgs + 2))
{
Server.dwScore = RASMON_CMD_ARG_GetDword(pArgs + 2);
}
if (RASMON_CMD_ARG_Present(pArgs + 3))
{
Server.dwPort = RASMON_CMD_ARG_GetDword(pArgs + 3);
}
if (RASMON_CMD_ARG_Present(pArgs + 4))
{
Server.dwTimeout = RASMON_CMD_ARG_GetDword(pArgs + 4);
}
if (RASMON_CMD_ARG_Present(pArgs + 5))
{
Server.dwSignature = RASMON_CMD_ARG_GetDword(pArgs + 5);
}
dwErr = RasAaaaServerAdd(RASAAAA_Auth, (PVOID)&Server);
BREAK_ON_DWERR(dwErr);
DisplayMessage(g_hModule, MSG_RASAAAA_MUST_RESTART_SERVICES);
} while (FALSE);
// Cleanup
//
{
RasAaaaServerCleanup(RASAAAA_Auth, (PVOID)&Server);
}
return dwErr;
}
DWORD
RasAaaaHandleAddAcctServ(
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;
RASAAAA_ACCT_SERVER Server;
RASMON_CMD_ARG pArgs[g_dwArgsAcctCount];
// Initialize
CopyMemory(pArgs, g_pArgsAcct, sizeof(g_pArgsAcct));
do
{
dwErr = RasAaaaServerInit(RASAAAA_Acct, (PVOID)&Server);
BREAK_ON_DWERR(dwErr);
// Parse the command line
//
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
Server.pszName = RASMON_CMD_ARG_GetPsz(pArgs + 0);
Server.pszSecret = RASMON_CMD_ARG_GetPsz(pArgs + 1);
if (RASMON_CMD_ARG_Present(pArgs + 2))
{
Server.dwScore = RASMON_CMD_ARG_GetDword(pArgs + 2);
}
if (RASMON_CMD_ARG_Present(pArgs + 3))
{
Server.dwPort = RASMON_CMD_ARG_GetDword(pArgs + 3);
}
if (RASMON_CMD_ARG_Present(pArgs + 4))
{
Server.dwTimeout = RASMON_CMD_ARG_GetDword(pArgs + 4);
}
if (RASMON_CMD_ARG_Present(pArgs + 5))
{
Server.dwMessages = RASMON_CMD_ARG_GetDword(pArgs + 5);
}
dwErr = RasAaaaServerAdd(RASAAAA_Acct, (PVOID)&Server);
BREAK_ON_DWERR(dwErr);
DisplayMessage(g_hModule, MSG_RASAAAA_MUST_RESTART_SERVICES);
} while (FALSE);
// Cleanup
//
{
RasAaaaServerCleanup(RASAAAA_Acct, (PVOID)&Server);
}
return dwErr;
}
DWORD
RasAaaaHandleDelAuthServ(
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, dwType = RASAAAA_Auth;
RASAAAA_AUTH_SERVER Server;
PVOID pvServer = (PVOID)&Server;
RASMON_CMD_ARG pArgs[] =
{
{
RASMONTR_CMD_TYPE_STRING,
{TOKEN_NAME, TRUE, FALSE},
NULL,
0,
NULL
}
};
ZeroMemory(&Server, sizeof(Server));
do
{
// Parse the command line
//
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
Server.pszName = RASMON_CMD_ARG_GetPsz(&pArgs[0]);
if (wcscmp(Server.pszName, TOKEN_RASAAAA_ALLSERVERS) == 0)
{
dwErr = RasAaaaServerEnum(
RASAAAA_Auth,
RasAaaaServerDeleteAuthCb,
NULL);
}
else
{
dwErr = RasAaaaServerDelete(dwType, pvServer);
}
BREAK_ON_DWERR( dwErr );
DisplayMessage(g_hModule, MSG_RASAAAA_MUST_RESTART_SERVICES);
} while (FALSE);
// Cleanup
//
{
RasAaaaServerCleanup(dwType, pvServer);
}
return dwErr;
}
DWORD
RasAaaaHandleDelAcctServ(
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, dwType = RASAAAA_Acct;
RASAAAA_ACCT_SERVER Server;
PVOID pvServer = (PVOID)&Server;
RASMON_CMD_ARG pArgs[] =
{
{
RASMONTR_CMD_TYPE_STRING,
{TOKEN_NAME, TRUE, FALSE},
NULL,
0,
NULL
}
};
ZeroMemory(&Server, sizeof(Server));
do
{
// Parse the command line
//
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
Server.pszName = RASMON_CMD_ARG_GetPsz(&pArgs[0]);
if (wcscmp(Server.pszName, TOKEN_RASAAAA_ALLSERVERS) == 0)
{
dwErr = RasAaaaServerEnum(
RASAAAA_Acct,
RasAaaaServerDeleteAcctCb,
NULL);
}
else
{
dwErr = RasAaaaServerDelete(dwType, pvServer);
}
BREAK_ON_DWERR( dwErr );
DisplayMessage(g_hModule, MSG_RASAAAA_MUST_RESTART_SERVICES);
} while (FALSE);
// Cleanup
//
{
RasAaaaServerCleanup(dwType, pvServer);
}
return dwErr;
}
DWORD
RasAaaaHandleSetAuth(
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, dwValue;
HKEY hkProviders = NULL;
TOKEN_VALUE rgEnum[] =
{
{TOKEN_WINDOWS, 1},
{TOKEN_RADIUS, 0}
};
RASMON_CMD_ARG pArgs[] =
{
{
RASMONTR_CMD_TYPE_ENUM,
{TOKEN_PROVIDER, TRUE, FALSE},
rgEnum,
sizeof(rgEnum) / sizeof(*rgEnum),
NULL
}
};
do
{
// Parse the command line
//
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
dwValue = RASMON_CMD_ARG_GetDword(&pArgs[0]);
dwErr = RasAaaaServerKeyOpen(
RASAAAA_Auth,
RASAAAA_F_Provider,
&hkProviders);
BREAK_ON_DWERR(dwErr);
dwErr = RutlRegWriteString(
hkProviders,
pszRegValActiveProvider,
(dwValue) ? pszGuidWinAuth : pszGuidRadAuth);
BREAK_ON_DWERR(dwErr);
DisplayMessage(g_hModule, MSG_RASAAAA_MUST_RESTART_SERVICES);
} while (FALSE);
// Cleanup
//
{
if (hkProviders)
{
RegCloseKey(hkProviders);
}
}
return dwErr;
}
DWORD
RasAaaaHandleSetAcct(
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, dwValue;
HKEY hkProviders = NULL;
PWCHAR pszProvider = NULL;
TOKEN_VALUE rgEnum[] =
{
{TOKEN_WINDOWS, 1},
{TOKEN_RADIUS, 0},
{TOKEN_NONE, 2}
};
RASMON_CMD_ARG pArgs[] =
{
{
RASMONTR_CMD_TYPE_ENUM,
{TOKEN_PROVIDER, TRUE, FALSE},
rgEnum,
sizeof(rgEnum) / sizeof(*rgEnum),
NULL
}
};
do
{
// Parse the command line
//
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
dwValue = RASMON_CMD_ARG_GetDword(&pArgs[0]);
dwErr = RasAaaaServerKeyOpen(
RASAAAA_Acct,
RASAAAA_F_Provider,
&hkProviders);
BREAK_ON_DWERR(dwErr);
if (dwValue == 0)
{
pszProvider = pszGuidRadAcct;
}
else if (dwValue == 1)
{
pszProvider = pszGuidWinAcct;
}
else
{
pszProvider = L"";
}
dwErr = RutlRegWriteString(
hkProviders,
pszRegValActiveProvider,
pszProvider);
BREAK_ON_DWERR(dwErr);
DisplayMessage(g_hModule, MSG_RASAAAA_MUST_RESTART_SERVICES);
} while (FALSE);
// Cleanup
//
{
if (hkProviders)
{
RegCloseKey(hkProviders);
}
}
return dwErr;
}
DWORD
RasAaaaHandleSetAuthServ(
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;
RASAAAA_AUTH_SERVER Server;
RASMON_CMD_ARG pArgs[g_dwArgsAuthCount];
// Initialize
CopyMemory(pArgs, g_pArgsAuth, sizeof(g_pArgsAuth));
do
{
dwErr = RasAaaaServerInit(RASAAAA_Auth, (PVOID)&Server);
BREAK_ON_DWERR(dwErr);
// Parse the command line
//
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
Server.pszName = RASMON_CMD_ARG_GetPsz(pArgs + 0);
Server.pszSecret = RASMON_CMD_ARG_GetPsz(pArgs + 1);
dwErr = RasAaaaServerRead(RASAAAA_Auth, (PVOID)&Server, NULL);
BREAK_ON_DWERR(dwErr);
if (RASMON_CMD_ARG_Present(pArgs + 2))
{
Server.dwScore = RASMON_CMD_ARG_GetDword(pArgs + 2);
}
if (RASMON_CMD_ARG_Present(pArgs + 3))
{
Server.dwPort = RASMON_CMD_ARG_GetDword(pArgs + 3);
}
if (RASMON_CMD_ARG_Present(pArgs + 4))
{
Server.dwTimeout = RASMON_CMD_ARG_GetDword(pArgs + 4);
}
if (RASMON_CMD_ARG_Present(pArgs + 5))
{
Server.dwSignature = RASMON_CMD_ARG_GetDword(pArgs + 5);
}
dwErr = RasAaaaServerWrite(RASAAAA_Auth, (PVOID)&Server, NULL, FALSE);
BREAK_ON_DWERR(dwErr);
DisplayMessage(g_hModule, MSG_RASAAAA_MUST_RESTART_SERVICES);
} while (FALSE);
// Cleanup
//
{
RasAaaaServerCleanup(RASAAAA_Auth, (PVOID)&Server);
}
return dwErr;
}
DWORD
RasAaaaHandleSetAcctServ(
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;
RASAAAA_ACCT_SERVER Server;
RASMON_CMD_ARG pArgs[g_dwArgsAcctCount];
// Initialize
CopyMemory(pArgs, g_pArgsAcct, sizeof(g_pArgsAcct));
do
{
dwErr = RasAaaaServerInit(RASAAAA_Acct, (PVOID)&Server);
BREAK_ON_DWERR(dwErr);
// Parse the command line
//
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
Server.pszName = RASMON_CMD_ARG_GetPsz(pArgs + 0);
Server.pszSecret = RASMON_CMD_ARG_GetPsz(pArgs + 1);
dwErr = RasAaaaServerRead(RASAAAA_Acct, (PVOID)&Server, NULL);
BREAK_ON_DWERR(dwErr);
if (RASMON_CMD_ARG_Present(pArgs + 2))
{
Server.dwScore = RASMON_CMD_ARG_GetDword(pArgs + 2);
}
if (RASMON_CMD_ARG_Present(pArgs + 3))
{
Server.dwPort = RASMON_CMD_ARG_GetDword(pArgs + 3);
}
if (RASMON_CMD_ARG_Present(pArgs + 4))
{
Server.dwTimeout = RASMON_CMD_ARG_GetDword(pArgs + 4);
}
if (RASMON_CMD_ARG_Present(pArgs + 5))
{
Server.dwMessages = RASMON_CMD_ARG_GetDword(pArgs + 5);
}
dwErr = RasAaaaServerWrite(RASAAAA_Acct, (PVOID)&Server, NULL, FALSE);
BREAK_ON_DWERR(dwErr);
DisplayMessage(g_hModule, MSG_RASAAAA_MUST_RESTART_SERVICES);
} while (FALSE);
// Cleanup
//
{
RasAaaaServerCleanup(RASAAAA_Acct, (PVOID)&Server);
}
return dwErr;
}
DWORD
RasAaaaHandleShowAuth(
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, dwProvider;
DWORD dwNumArgs = dwArgCount - dwCurrentIndex;
PWCHAR pszProvider = (PWCHAR)TOKEN_WINDOWS;
do
{
// Make sure no arguments were passed
//
if (dwNumArgs > 0)
{
dwErr = ERROR_INVALID_SYNTAX;
break;
}
dwErr = RasAaaaProviderRead(RASAAAA_Auth, &dwProvider);
BREAK_ON_DWERR(dwErr);
if (dwProvider == RASAAAA_Radius)
{
pszProvider = (PWCHAR)TOKEN_RADIUS;
}
DisplayMessage(
g_hModule,
MSG_RASAAAA_SHOW_AUTH,
pszProvider);
} while (FALSE);
// Cleanup
{
}
return dwErr;
}
DWORD
RasAaaaHandleShowAcct(
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, dwProvider;
DWORD dwNumArgs = dwArgCount - dwCurrentIndex;
PWCHAR pszProvider = NULL;
do
{
// Make sure no arguments were passed
//
if (dwNumArgs > 0)
{
dwErr = ERROR_INVALID_SYNTAX;
break;
}
// Show the authentication provider
//
dwErr = RasAaaaProviderRead(RASAAAA_Acct, &dwProvider);
BREAK_ON_DWERR(dwErr);
if (dwProvider == RASAAAA_Radius)
{
pszProvider = (PWCHAR)TOKEN_RADIUS;
}
else if (dwProvider == RASAAAA_Windows)
{
pszProvider = (PWCHAR)TOKEN_WINDOWS;
}
else
{
pszProvider = (PWCHAR)TOKEN_NONE;
}
DisplayMessage(
g_hModule,
MSG_RASAAAA_SHOW_ACCT,
pszProvider);
} while (FALSE);
// Cleanup
{
}
return dwErr;
}
DWORD
RasAaaaHandleShowAuthServ(
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;
RASAAAA_AUTH_SERVER Server;
RASMON_CMD_ARG pArgs[] =
{
{
RASMONTR_CMD_TYPE_STRING,
{TOKEN_NAME, FALSE, FALSE},
NULL,
0,
NULL
}
};
do
{
ZeroMemory(&Server, sizeof(Server));
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
Server.pszName = RASMON_CMD_ARG_GetPsz(pArgs + 0);
// Display the header
//
DisplayMessage(
g_hModule,
MSG_RASAAAA_SHOW_AUTHSERV_HDR);
if (Server.pszName)
{
dwErr = RasAaaaServerRead(
RASAAAA_Auth,
(PVOID)&Server,
NULL);
BREAK_ON_DWERR(dwErr);
dwErr = RasAaaaServerAuthShow(
(PVOID)&Server,
NULL);
BREAK_ON_DWERR(dwErr);
}
else
{
// Show all the servers
//
dwErr = RasAaaaServerEnum(
RASAAAA_Auth,
RasAaaaServerAuthShow,
NULL);
BREAK_ON_DWERR(dwErr);
}
} while (FALSE);
// Cleanup
{
RasAaaaServerCleanup(RASAAAA_Auth, (PVOID)&Server);
}
return dwErr;
}
DWORD
RasAaaaHandleShowAcctServ(
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;
RASAAAA_ACCT_SERVER Server;
RASMON_CMD_ARG pArgs[] =
{
{
RASMONTR_CMD_TYPE_STRING,
{TOKEN_NAME, FALSE, FALSE},
NULL,
0,
NULL
}
};
do
{
ZeroMemory(&Server, sizeof(Server));
dwErr = RutlParse(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pbDone,
pArgs,
sizeof(pArgs)/sizeof(*pArgs));
BREAK_ON_DWERR( dwErr );
Server.pszName = RASMON_CMD_ARG_GetPsz(pArgs + 0);
// Display the header
//
DisplayMessage(
g_hModule,
MSG_RASAAAA_SHOW_ACCTSERV_HDR);
if (Server.pszName)
{
dwErr = RasAaaaServerRead(
RASAAAA_Acct,
(PVOID)&Server,
NULL);
BREAK_ON_DWERR(dwErr);
dwErr = RasAaaaServerAcctShow(
(PVOID)&Server,
NULL);
BREAK_ON_DWERR(dwErr);
}
else
{
// Show all the servers
//
dwErr = RasAaaaServerEnum(
RASAAAA_Acct,
RasAaaaServerAcctShow,
NULL);
BREAK_ON_DWERR(dwErr);
}
} while (FALSE);
// Cleanup
{
RasAaaaServerCleanup(RASAAAA_Auth, (PVOID)&Server);
}
return dwErr;
}
Reference in a new issue Copy permalink