You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1226 lines
29 KiB
1226 lines
29 KiB
/*
|
|
File: routerif.c
|
|
|
|
Defines callbacks needed to deal with interfaces supported by
|
|
the router.
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
|
|
DWORD
|
|
RtruiInterfaceShow(
|
|
IN PWCHAR pwszIfName,
|
|
IN DWORD dwLevel,
|
|
IN DWORD dwFormat,
|
|
IN PVOID pvData,
|
|
IN HANDLE hData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Prints interface info to display or file
|
|
|
|
Arguments:
|
|
|
|
pIfInfo - Info for adding the interface
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD dwErr, dwSize;
|
|
WCHAR rgwcIfDesc[MAX_INTERFACE_NAME_LEN + 1];
|
|
PWCHAR pwszEnabled, pwszDisabled, pwszConnected, pwszDisconn;
|
|
PWCHAR pwszConnecting, pwszUnreachable, pwszClient, pwszHome, pwszFull;
|
|
PWCHAR pwszDedicated, pwszInternal, pwszLoop;
|
|
PWCHAR pwszAdminState, pwszState, pwszType;
|
|
MPR_INTERFACE_0* pIfInfo = (MPR_INTERFACE_0*)pvData;
|
|
BOOL bDump = (hData) && (*((BOOL*)hData));
|
|
|
|
pwszEnabled = MakeString(g_hModule, STRING_ENABLED);
|
|
pwszDisabled = MakeString(g_hModule, STRING_DISABLED);
|
|
pwszConnected = MakeString(g_hModule, STRING_CONNECTED);
|
|
pwszDisconn = MakeString(g_hModule, STRING_DISCONNECTED);
|
|
pwszConnecting = MakeString(g_hModule, STRING_CONNECTING);
|
|
pwszUnreachable = MakeString(g_hModule, STRING_UNREACHABLE);
|
|
pwszClient = MakeString(g_hModule, STRING_CLIENT);
|
|
pwszHome = MakeString(g_hModule, STRING_HOME_ROUTER);
|
|
pwszFull = MakeString(g_hModule, STRING_FULL_ROUTER);
|
|
pwszDedicated = MakeString(g_hModule, STRING_DEDICATED);
|
|
pwszInternal = MakeString(g_hModule, STRING_INTERNAL);
|
|
pwszLoop = MakeString(g_hModule, STRING_LOOPBACK);
|
|
|
|
do
|
|
{
|
|
if(!pwszEnabled or
|
|
!pwszDisabled or
|
|
!pwszConnected or
|
|
!pwszDisconn or
|
|
!pwszConnecting or
|
|
!pwszUnreachable or
|
|
!pwszClient or
|
|
!pwszHome or
|
|
!pwszFull or
|
|
!pwszDedicated or
|
|
!pwszInternal or
|
|
!pwszLoop)
|
|
{
|
|
|
|
DisplayError(NULL,
|
|
ERROR_NOT_ENOUGH_MEMORY);
|
|
|
|
break;
|
|
}
|
|
|
|
dwSize = sizeof(rgwcIfDesc);
|
|
|
|
IfutlGetInterfaceDescription(pIfInfo->wszInterfaceName,
|
|
rgwcIfDesc,
|
|
&dwSize);
|
|
|
|
switch(pIfInfo->dwConnectionState)
|
|
{
|
|
case ROUTER_IF_STATE_UNREACHABLE:
|
|
{
|
|
pwszState = pwszUnreachable;
|
|
|
|
break;
|
|
}
|
|
|
|
case ROUTER_IF_STATE_DISCONNECTED:
|
|
{
|
|
pwszState = pwszDisconn;
|
|
|
|
break;
|
|
}
|
|
|
|
case ROUTER_IF_STATE_CONNECTING:
|
|
{
|
|
pwszState = pwszConnecting;
|
|
|
|
break;
|
|
}
|
|
|
|
case ROUTER_IF_STATE_CONNECTED:
|
|
{
|
|
pwszState = pwszConnected;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
pwszState = L"";
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if (bDump == FALSE)
|
|
{
|
|
switch(pIfInfo->dwIfType)
|
|
{
|
|
case ROUTER_IF_TYPE_CLIENT:
|
|
pwszType = pwszClient;
|
|
break;
|
|
|
|
case ROUTER_IF_TYPE_HOME_ROUTER:
|
|
pwszType = pwszHome;
|
|
break;
|
|
|
|
case ROUTER_IF_TYPE_FULL_ROUTER:
|
|
pwszType = pwszFull;
|
|
break;
|
|
|
|
case ROUTER_IF_TYPE_DEDICATED:
|
|
pwszType = pwszDedicated;
|
|
break;
|
|
|
|
case ROUTER_IF_TYPE_INTERNAL:
|
|
pwszType = pwszInternal;
|
|
break;
|
|
|
|
case ROUTER_IF_TYPE_LOOPBACK:
|
|
pwszType = pwszLoop;
|
|
break;
|
|
|
|
default:
|
|
pwszType = L"";
|
|
break;
|
|
}
|
|
|
|
if(pIfInfo->fEnabled)
|
|
{
|
|
pwszAdminState = pwszEnabled;
|
|
}
|
|
else
|
|
{
|
|
pwszAdminState = pwszDisabled;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(pIfInfo->dwIfType)
|
|
{
|
|
case ROUTER_IF_TYPE_FULL_ROUTER:
|
|
pwszType = TOKEN_FULL;
|
|
break;
|
|
|
|
default:
|
|
pwszType = L"";
|
|
break;
|
|
}
|
|
|
|
if(pIfInfo->fEnabled)
|
|
{
|
|
pwszAdminState = TOKEN_VALUE_ENABLED;
|
|
}
|
|
else
|
|
{
|
|
pwszAdminState = TOKEN_VALUE_DISABLED;
|
|
}
|
|
}
|
|
|
|
if (bDump)
|
|
{
|
|
|
|
PWCHAR pwszQuoted = NULL;
|
|
|
|
if (wcscmp(pIfInfo->wszInterfaceName, rgwcIfDesc))
|
|
{
|
|
pwszQuoted = MakeQuotedString( rgwcIfDesc );
|
|
}
|
|
else
|
|
{
|
|
pwszQuoted = MakeQuotedString( pIfInfo->wszInterfaceName );
|
|
}
|
|
|
|
if (pIfInfo->dwIfType == ROUTER_IF_TYPE_FULL_ROUTER)
|
|
{
|
|
WCHAR pwszUser[256], pwszDomain[256];
|
|
PWCHAR pszQuoteUser = NULL, pszQuoteDomain = NULL;
|
|
|
|
DisplayMessageT( DMP_IF_ADD_IF,
|
|
pwszQuoted,
|
|
pwszType);
|
|
|
|
DisplayMessageT( DMP_IF_SET_IF,
|
|
pwszQuoted,
|
|
pwszAdminState);
|
|
|
|
dwErr = RtrdbInterfaceReadCredentials(
|
|
pIfInfo->wszInterfaceName,
|
|
pwszUser,
|
|
NULL,
|
|
pwszDomain);
|
|
|
|
if (dwErr == NO_ERROR)
|
|
{
|
|
pszQuoteUser = MakeQuotedString( pwszUser );
|
|
if (pszQuoteUser == NULL)
|
|
{
|
|
break;
|
|
}
|
|
if (*pwszDomain == L'\0')
|
|
{
|
|
DisplayMessageT( DMP_IF_SET_CRED_IF_NOD,
|
|
pwszQuoted,
|
|
pszQuoteUser);
|
|
}
|
|
else
|
|
{
|
|
pszQuoteDomain = MakeQuotedString( pwszDomain );
|
|
if (pszQuoteUser == NULL)
|
|
{
|
|
FreeString(pszQuoteUser);
|
|
break;
|
|
}
|
|
DisplayMessageT( DMP_IF_SET_CRED_IF,
|
|
pwszQuoted,
|
|
pszQuoteUser,
|
|
pszQuoteDomain);
|
|
FreeString(pszQuoteDomain);
|
|
}
|
|
}
|
|
|
|
DisplayMessageT( DMP_IF_NEWLINE );
|
|
}
|
|
|
|
FreeQuotedString(pwszQuoted);
|
|
}
|
|
|
|
else
|
|
{
|
|
DisplayMessage(g_hModule,
|
|
(dwFormat>0)? MSG_IF_ENTRY_LONG : MSG_IF_ENTRY_SHORT,
|
|
pwszAdminState,
|
|
pwszState,
|
|
pwszType,
|
|
rgwcIfDesc );
|
|
}
|
|
}while(FALSE);
|
|
|
|
|
|
if(pwszEnabled)
|
|
{
|
|
FreeString(pwszEnabled);
|
|
}
|
|
|
|
if(pwszDisabled)
|
|
{
|
|
FreeString(pwszDisabled);
|
|
}
|
|
|
|
if(pwszConnected)
|
|
{
|
|
FreeString(pwszConnected);
|
|
}
|
|
|
|
if(pwszDisconn)
|
|
{
|
|
FreeString(pwszDisconn);
|
|
}
|
|
|
|
if(pwszConnecting)
|
|
{
|
|
FreeString(pwszConnecting);
|
|
}
|
|
|
|
if(pwszUnreachable)
|
|
{
|
|
FreeString(pwszUnreachable);
|
|
}
|
|
|
|
if(pwszClient)
|
|
{
|
|
FreeString(pwszClient);
|
|
}
|
|
|
|
if(pwszHome)
|
|
{
|
|
FreeString(pwszHome);
|
|
}
|
|
|
|
if(pwszFull)
|
|
{
|
|
FreeString(pwszFull);
|
|
}
|
|
|
|
if(pwszDedicated)
|
|
{
|
|
FreeString(pwszDedicated);
|
|
}
|
|
|
|
if(pwszInternal)
|
|
{
|
|
FreeString(pwszInternal);
|
|
}
|
|
|
|
if(pwszLoop)
|
|
{
|
|
FreeString(pwszLoop);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RtrHandleResetAll(
|
|
IN PWCHAR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handler for displaying interfaces
|
|
|
|
Arguments:
|
|
|
|
ppwcArguments - Argument array
|
|
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
|
|
dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwSize;
|
|
MPR_INTERFACE_0 If0;
|
|
WCHAR pszName[MAX_INTERFACE_NAME_LEN];
|
|
|
|
do
|
|
{
|
|
// Make sure no arguments were passed in
|
|
//
|
|
if (dwArgCount - dwCurrentIndex != 0)
|
|
{
|
|
dwErr = ERROR_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
|
|
dwErr = RtrdbResetAll();
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RtrHandleAddDel(
|
|
IN PWCHAR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL bAdd
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The actual parser for the add and delete commands
|
|
|
|
Arguments:
|
|
|
|
ppwcArguments - Argument array
|
|
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
|
|
dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
|
|
bAdd - TRUE to add the interface
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD i, dwNumArgs, dwRes, dwErr, dwIfType, dwSize;
|
|
MPR_INTERFACE_0 IfInfo;
|
|
PWCHAR pszIfDesc = NULL;
|
|
TOKEN_VALUE rgEnumType[] =
|
|
{
|
|
{TOKEN_FULL, ROUTER_IF_TYPE_FULL_ROUTER}
|
|
};
|
|
IFMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
IFMON_CMD_TYPE_STRING,
|
|
{TOKEN_NAME, TRUE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
},
|
|
|
|
{
|
|
IFMON_CMD_TYPE_ENUM,
|
|
{TOKEN_TYPE, FALSE, FALSE},
|
|
rgEnumType,
|
|
sizeof(rgEnumType) / sizeof(*rgEnumType),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
// Initialize
|
|
//
|
|
ZeroMemory(&IfInfo, sizeof(IfInfo));
|
|
IfInfo.fEnabled = TRUE;
|
|
|
|
|
|
do
|
|
{
|
|
// Parse out the values
|
|
//
|
|
dwErr = IfutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
NULL,
|
|
pArgs,
|
|
sizeof(pArgs) / sizeof(*pArgs));
|
|
if (dwErr isnot NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Get the arguments that were specified
|
|
//
|
|
pszIfDesc = IFMON_CMD_ARG_GetPsz(&pArgs[0]);
|
|
if (!pszIfDesc) {
|
|
dwErr = ERROR_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
|
|
IfInfo.dwIfType = IFMON_CMD_ARG_GetDword(&pArgs[1]);
|
|
|
|
if(bAdd)
|
|
{
|
|
// Make sure the type was specified
|
|
//
|
|
if (! pArgs[1].rgTag.bPresent)
|
|
{
|
|
dwErr = ERROR_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
|
|
wcscpy(
|
|
IfInfo.wszInterfaceName,
|
|
pszIfDesc
|
|
);
|
|
|
|
dwErr = RtrdbInterfaceAdd(
|
|
IfInfo.wszInterfaceName,
|
|
0,
|
|
(PVOID)&IfInfo);
|
|
}
|
|
else
|
|
{
|
|
WCHAR pszName[MAX_INTERFACE_NAME_LEN + 1];
|
|
dwSize = sizeof(pszName);
|
|
|
|
IfutlGetInterfaceName(
|
|
pszIfDesc,
|
|
pszName,
|
|
&dwSize);
|
|
|
|
dwErr = RtrdbInterfaceDelete(pszName);
|
|
}
|
|
|
|
} while(FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
IfutlFree(pszIfDesc);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RtrHandleAdd(
|
|
IN PWCHAR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handler for adding an dial interface to the router
|
|
|
|
Arguments:
|
|
|
|
ppwcArguments - Argument array
|
|
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
|
|
dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
return RtrHandleAddDel(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
TRUE);
|
|
|
|
}
|
|
|
|
DWORD
|
|
RtrHandleDel(
|
|
IN PWCHAR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handler for deleting a dial interface or from the router
|
|
|
|
Arguments:
|
|
|
|
ppwcArguments - Argument array
|
|
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
|
|
dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
return RtrHandleAddDel(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
FALSE);
|
|
|
|
}
|
|
|
|
DWORD
|
|
RtrHandleSet(
|
|
IN PWCHAR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handler for displaying interfaces
|
|
|
|
Arguments:
|
|
|
|
ppwcArguments - Argument array
|
|
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
|
|
dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwSize;
|
|
MPR_INTERFACE_0 If0;
|
|
TOKEN_VALUE rgEnumAdmin[] =
|
|
{
|
|
{TOKEN_VALUE_ENABLED, TRUE},
|
|
{TOKEN_VALUE_DISABLED, FALSE}
|
|
};
|
|
TOKEN_VALUE rgEnumConnect[] =
|
|
{
|
|
{TOKEN_VALUE_CONNECTED, TRUE},
|
|
{TOKEN_VALUE_DISCONNECTED, FALSE}
|
|
};
|
|
IFMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
IFMON_CMD_TYPE_STRING,
|
|
{TOKEN_NAME, TRUE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
},
|
|
|
|
{
|
|
IFMON_CMD_TYPE_ENUM,
|
|
{TOKEN_ADMIN, FALSE, FALSE},
|
|
rgEnumAdmin,
|
|
sizeof(rgEnumAdmin) / sizeof(*rgEnumAdmin),
|
|
NULL
|
|
},
|
|
|
|
{
|
|
IFMON_CMD_TYPE_ENUM,
|
|
{TOKEN_CONNECT, FALSE, FALSE},
|
|
rgEnumConnect,
|
|
sizeof(rgEnumConnect) / sizeof(*rgEnumConnect),
|
|
NULL
|
|
},
|
|
|
|
{
|
|
IFMON_CMD_TYPE_STRING,
|
|
{TOKEN_NEWNAME, FALSE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
}
|
|
};
|
|
PWCHAR pszIfName = NULL, pszNewName = NULL;
|
|
WCHAR pszName[MAX_INTERFACE_NAME_LEN];
|
|
BOOL fEnable = FALSE, fConnect = FALSE;
|
|
BOOL fEnablePresent = FALSE, fConnectPresent = FALSE;
|
|
|
|
do
|
|
{
|
|
// Parse
|
|
//
|
|
dwErr = IfutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
NULL,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Get the returned values from the parse
|
|
//
|
|
pszIfName = IFMON_CMD_ARG_GetPsz(&pArgs[0]);
|
|
fEnable = IFMON_CMD_ARG_GetDword(&pArgs[1]);
|
|
fConnect = IFMON_CMD_ARG_GetDword(&pArgs[2]);
|
|
pszNewName = IFMON_CMD_ARG_GetPsz(&pArgs[3]);
|
|
fEnablePresent = pArgs[1].rgTag.bPresent;
|
|
fConnectPresent = pArgs[2].rgTag.bPresent;
|
|
|
|
// Get the interface info so that we can
|
|
// make sure we have the right type.
|
|
//
|
|
dwSize = sizeof(pszName);
|
|
dwErr = GetIfNameFromFriendlyName(
|
|
pszIfName,
|
|
pszName,
|
|
&dwSize);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
ZeroMemory(&If0, sizeof(If0));
|
|
dwErr = RtrdbInterfaceRead(
|
|
pszName,
|
|
0,
|
|
(PVOID*)&If0,
|
|
fEnablePresent? TRUE: FALSE);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Rename the interface if that is the request
|
|
//
|
|
if ( If0.dwIfType == ROUTER_IF_TYPE_DEDICATED )
|
|
{
|
|
if (!pszNewName && !fEnablePresent)
|
|
{
|
|
DisplayError(
|
|
g_hModule,
|
|
EMSG_CANT_FIND_EOPT);
|
|
|
|
dwErr = ERROR_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
|
|
if (g_pwszRouter)
|
|
{
|
|
DisplayError(
|
|
g_hModule,
|
|
EMSG_IF_NEWNAME_ONLY_FOR_LOCAL);
|
|
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
if (fConnectPresent)
|
|
{
|
|
DisplayError(
|
|
g_hModule,
|
|
EMSG_IF_LAN_ONLY_COMMAND);
|
|
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
// Rename the interface
|
|
//
|
|
if (pszNewName)
|
|
{
|
|
dwErr = RtrdbInterfaceRename(
|
|
pszName,
|
|
0,
|
|
(PVOID)&If0,
|
|
pszNewName);
|
|
if (dwErr != NO_ERROR)
|
|
break;
|
|
}
|
|
|
|
if (fEnablePresent)
|
|
{
|
|
dwErr = RtrdbInterfaceEnableDisable(
|
|
pszIfName,
|
|
//(PVOID)&If0,
|
|
fEnable
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (pszNewName)
|
|
{
|
|
DisplayError(
|
|
g_hModule,
|
|
EMSG_IF_NEWNAME_ONLY_FOR_LAN);
|
|
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
// Make sure that at least one option was specified
|
|
//
|
|
if (!fEnablePresent && !fConnectPresent)
|
|
{
|
|
dwErr = ERROR_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
|
|
// Validate the interface type
|
|
//
|
|
//if ( ( If0.dwIfType == ROUTER_IF_TYPE_DEDICATED ) ||
|
|
// ( If0.dwIfType == ROUTER_IF_TYPE_INTERNAL )
|
|
// )
|
|
if ( If0.dwIfType != ROUTER_IF_TYPE_FULL_ROUTER )
|
|
{
|
|
DisplayError(
|
|
g_hModule,
|
|
EMSG_IF_WAN_ONLY_COMMAND);
|
|
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
// Allow the connection request to override
|
|
// the admin enabling.
|
|
if (fConnectPresent)
|
|
{
|
|
if (!IfutlIsRouterRunning())
|
|
{
|
|
DisplayError(
|
|
g_hModule,
|
|
EMSG_IF_CONNECT_ONLY_WHEN_ROUTER_RUNNING);
|
|
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
if (fConnect)
|
|
{
|
|
fEnablePresent = TRUE;
|
|
fEnable = TRUE;
|
|
}
|
|
}
|
|
|
|
// Enable if requested
|
|
//
|
|
if (fEnablePresent)
|
|
{
|
|
// Enable/disable the interface
|
|
//
|
|
If0.fEnabled = fEnable;
|
|
|
|
// Commit
|
|
//
|
|
dwErr = RtrdbInterfaceWrite(
|
|
If0.wszInterfaceName,
|
|
0,
|
|
(PVOID)&If0);
|
|
BREAK_ON_DWERR(dwErr);
|
|
}
|
|
|
|
// Connect if requested
|
|
//
|
|
if (fConnectPresent)
|
|
{
|
|
if (fConnect)
|
|
{
|
|
dwErr = MprAdminInterfaceConnect(
|
|
g_hMprAdmin,
|
|
If0.hInterface,
|
|
NULL,
|
|
TRUE);
|
|
|
|
BREAK_ON_DWERR(dwErr);
|
|
}
|
|
else
|
|
{
|
|
dwErr = MprAdminInterfaceDisconnect(
|
|
g_hMprAdmin,
|
|
If0.hInterface);
|
|
|
|
BREAK_ON_DWERR(dwErr);
|
|
}
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
IfutlFree(pszIfName);
|
|
IfutlFree(pszNewName);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RtrHandleSetCredentials(
|
|
IN PWCHAR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handler for displaying interfaces
|
|
|
|
Arguments:
|
|
|
|
ppwcArguments - Argument array
|
|
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
|
|
dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwSize;
|
|
MPR_INTERFACE_0 If0;
|
|
IFMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
IFMON_CMD_TYPE_STRING,
|
|
{TOKEN_NAME, TRUE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
},
|
|
|
|
{
|
|
IFMON_CMD_TYPE_STRING,
|
|
{TOKEN_USER, TRUE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
},
|
|
|
|
{
|
|
IFMON_CMD_TYPE_STRING,
|
|
{TOKEN_DOMAIN, FALSE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
},
|
|
|
|
{
|
|
IFMON_CMD_TYPE_STRING,
|
|
{TOKEN_PASSWORD, FALSE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
}
|
|
};
|
|
PWCHAR pszIfName = NULL, pszUser = NULL;
|
|
PWCHAR pszPassword = NULL, pszDomain = NULL;
|
|
WCHAR pszName[MAX_INTERFACE_NAME_LEN];
|
|
|
|
do
|
|
{
|
|
// Parse
|
|
//
|
|
dwErr = IfutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
NULL,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Get the returned values from the parse
|
|
//
|
|
pszIfName = IFMON_CMD_ARG_GetPsz(&pArgs[0]);
|
|
pszUser = IFMON_CMD_ARG_GetPsz(&pArgs[1]);
|
|
pszDomain = IFMON_CMD_ARG_GetPsz(&pArgs[2]);
|
|
pszPassword = IFMON_CMD_ARG_GetPsz(&pArgs[3]);
|
|
|
|
// Get the interface info so that we can
|
|
// make sure we have the right type.
|
|
//
|
|
dwSize = sizeof(pszName);
|
|
dwErr = GetIfNameFromFriendlyName(
|
|
pszIfName,
|
|
pszName,
|
|
&dwSize);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RtrdbInterfaceWriteCredentials(
|
|
pszName,
|
|
pszUser,
|
|
pszPassword,
|
|
pszDomain);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
IfutlFree(pszIfName);
|
|
IfutlFree(pszUser);
|
|
if (pszPassword)
|
|
RtlSecureZeroMemory(pszPassword, wcslen(pszPassword)*sizeof(WCHAR));
|
|
IfutlFree(pszPassword);
|
|
IfutlFree(pszDomain);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RtrHandleShow(
|
|
IN PWCHAR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handler for displaying interfaces
|
|
|
|
Arguments:
|
|
|
|
ppwcArguments - Argument array
|
|
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
|
|
dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwSize;
|
|
MPR_INTERFACE_0 If0;
|
|
IFMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
IFMON_CMD_TYPE_STRING,
|
|
{TOKEN_NAME, FALSE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
}
|
|
};
|
|
PWCHAR pszIfName = NULL;
|
|
WCHAR pszName[MAX_INTERFACE_NAME_LEN];
|
|
|
|
do
|
|
{
|
|
// Parse
|
|
//
|
|
dwErr = IfutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
NULL,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Get the returned values from the parse
|
|
//
|
|
pszIfName = IFMON_CMD_ARG_GetPsz(&pArgs[0]);
|
|
|
|
// Handle the no argument case
|
|
//
|
|
if (pszIfName == NULL)
|
|
{
|
|
RtrdbInterfaceEnumerate(0, 0, RtruiInterfaceShow, NULL);
|
|
dwErr = NO_ERROR;
|
|
break;
|
|
}
|
|
|
|
// Map the name
|
|
//
|
|
dwSize = sizeof(pszName);
|
|
GetIfNameFromFriendlyName(
|
|
pszIfName,
|
|
pszName,
|
|
&dwSize);
|
|
|
|
// Get the info
|
|
//
|
|
dwErr = RtrdbInterfaceRead(
|
|
pszName,
|
|
0,
|
|
(PVOID)&If0,
|
|
FALSE);
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
RtruiInterfaceShow(
|
|
If0.wszInterfaceName,
|
|
0,
|
|
1,
|
|
(PVOID)&If0,
|
|
NULL
|
|
);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
//
|
|
{
|
|
if (pszIfName != NULL)
|
|
{
|
|
IfutlFree(pszIfName);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RtrHandleShowCredentials(
|
|
IN PWCHAR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handler for showing credentials of an interface
|
|
|
|
Arguments:
|
|
|
|
ppwcArguments - Argument array
|
|
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
|
|
dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwSize;
|
|
MPR_INTERFACE_0 If0;
|
|
IFMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
IFMON_CMD_TYPE_STRING,
|
|
{TOKEN_NAME, TRUE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
},
|
|
};
|
|
PWCHAR pszIfName = NULL;
|
|
WCHAR pszName[MAX_INTERFACE_NAME_LEN];
|
|
WCHAR pszUser[256], pszDomain[256], pszPassword[256];
|
|
|
|
do
|
|
{
|
|
// Parse
|
|
//
|
|
dwErr = IfutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
NULL,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Get the returned values from the parse
|
|
//
|
|
pszIfName = IFMON_CMD_ARG_GetPsz(&pArgs[0]);
|
|
|
|
// Get the interface info so that we can
|
|
// make sure we have the right type.
|
|
//
|
|
dwSize = sizeof(pszName);
|
|
dwErr = GetIfNameFromFriendlyName(
|
|
pszIfName,
|
|
pszName,
|
|
&dwSize);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RtrdbInterfaceReadCredentials(
|
|
pszName,
|
|
pszUser,
|
|
pszPassword,
|
|
pszDomain);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_IF_CREDENTIALS,
|
|
pszIfName,
|
|
pszUser,
|
|
pszDomain,
|
|
pszPassword);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
RtlSecureZeroMemory(pszPassword, sizeof(pszPassword));
|
|
|
|
IfutlFree(pszIfName);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RtrHandleDump(
|
|
PWCHAR *ppwcArguments,
|
|
DWORD dwCurrentIndex,
|
|
DWORD dwArgCount,
|
|
BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr, dwCount, dwTotal;
|
|
ULONG i;
|
|
PMPR_INTERFACE_0 pIfTable;
|
|
BOOL bFormat = TRUE;
|
|
|
|
// Display dump header
|
|
//
|
|
DisplayMessage(g_hModule, DMP_IF_HEADER_COMMENTS);
|
|
|
|
DisplayMessageT(DMP_IF_HEADER);
|
|
|
|
// Display the interfaces
|
|
//
|
|
RtrdbInterfaceEnumerate(0, 0, RtruiInterfaceShow, &bFormat);
|
|
|
|
// Display dump footer
|
|
//
|
|
DisplayMessageT(DMP_IF_FOOTER);
|
|
|
|
DisplayMessage(g_hModule, DMP_IF_FOOTER_COMMENTS);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RtrDump(
|
|
IN PWCHAR *ppwcArguments,
|
|
IN DWORD dwArgCount
|
|
)
|
|
{
|
|
BOOL bDone;
|
|
|
|
return RtrHandleDump(ppwcArguments, 1, dwArgCount, &bDone);
|
|
}
|
|
|