2364 lines
66 KiB
C++
2364 lines
66 KiB
C++
#include <windows.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <winldap.h>
|
||
#include <schedule.h>
|
||
#include <mkdsx.h>
|
||
#include <frsrpc.h>
|
||
#include <ntdsapi.h>
|
||
|
||
//Global data
|
||
BOOL bVerboseMode = FALSE;
|
||
PWCHAR DcName = NULL;
|
||
PLDAP pLdap = NULL;
|
||
BOOL bDebugMode = FALSE;
|
||
BOOL bAffectAll = FALSE;
|
||
PBYTE SchedMask = NULL;
|
||
PBYTE SchedOverride = NULL;
|
||
|
||
//
|
||
// Static arrays to conver the value of the options attribute to
|
||
// string for display.
|
||
//
|
||
|
||
DWORD NtdsConnOptions[5] = {0,
|
||
NTDSCONN_OPT_IS_GENERATED,
|
||
NTDSCONN_OPT_TWOWAY_SYNC,
|
||
NTDSCONN_OPT_OVERRIDE_NOTIFY_DEFAULT,
|
||
NTDSCONN_OPT_USE_NOTIFY};
|
||
|
||
WCHAR NtdsConnOptionsStr[][MAX_PATH] = {L"Not Used",
|
||
L"IsGenerated",
|
||
L"TwoWaySync",
|
||
L"OverrideNotifyDefault",
|
||
L"UseNotify"};
|
||
|
||
DWORD NtdsConnOptionsMax = NTDSCONN_OPT_IS_GENERATED |
|
||
NTDSCONN_OPT_TWOWAY_SYNC |
|
||
NTDSCONN_OPT_OVERRIDE_NOTIFY_DEFAULT |
|
||
NTDSCONN_OPT_USE_NOTIFY;
|
||
|
||
|
||
VOID
|
||
PrintScheduleGrid(
|
||
PUCHAR ScheduleData,
|
||
DWORD Mask
|
||
);
|
||
|
||
VOID
|
||
PrintSchedule(
|
||
PSCHEDULE Schedule,
|
||
DWORD Mask
|
||
);
|
||
|
||
|
||
DWORD
|
||
BindToDC (
|
||
IN PWCHAR pszDC,
|
||
OUT PLDAP *ppLDAP
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Sets up an LDAP connection to the specified server
|
||
|
||
Arguments:
|
||
|
||
pwszDC - DS DC to bind to
|
||
ppLDAP - The LDAP connection information is returned here
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS - Success
|
||
|
||
--*/
|
||
{
|
||
DWORD dwErr = ERROR_SUCCESS;
|
||
ULONG ulOptions;
|
||
|
||
//
|
||
// if ldap_open is called with a server name the api will call DsGetDcName
|
||
// passing the server name as the domainname parm...bad, because
|
||
// DsGetDcName will make a load of DNS queries based on the server name,
|
||
// it is designed to construct these queries from a domain name...so all
|
||
// these queries will be bogus, meaning they will waste network bandwidth,
|
||
// time to fail, and worst case cause expensive on demand links to come up
|
||
// as referrals/forwarders are contacted to attempt to resolve the bogus
|
||
// names. By setting LDAP_OPT_AREC_EXCLUSIVE to on using ldap_set_option
|
||
// after the ldap_init but before any other operation using the ldap
|
||
// handle from ldap_init, the delayed connection setup will not call
|
||
// DsGetDcName, just gethostbyname, or if an IP is passed, the ldap client
|
||
// will detect that and use the address directly.
|
||
//
|
||
// *ppLDAP = ldap_open(pszDC, LDAP_PORT);
|
||
*ppLDAP = ldap_init(pszDC, LDAP_PORT);
|
||
|
||
if(*ppLDAP == NULL)
|
||
{
|
||
dwErr = ERROR_PATH_NOT_FOUND;
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// set the options.
|
||
//
|
||
ulOptions = PtrToUlong(LDAP_OPT_ON);
|
||
ldap_set_option(*ppLDAP, LDAP_OPT_AREC_EXCLUSIVE, &ulOptions);
|
||
|
||
//
|
||
// Do a bind...
|
||
//
|
||
dwErr = ldap_bind_s(*ppLDAP,
|
||
NULL,
|
||
NULL,
|
||
LDAP_AUTH_NEGOTIATE);
|
||
}
|
||
|
||
return(dwErr);
|
||
}
|
||
|
||
PWCHAR
|
||
FrsWcsDup(
|
||
PWCHAR OldStr
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Duplicate a string using our memory allocater
|
||
|
||
Arguments:
|
||
OldArg - string to duplicate
|
||
|
||
Return Value:
|
||
Duplicated string. Free with FrsFree().
|
||
--*/
|
||
{
|
||
PWCHAR NewStr;
|
||
|
||
//
|
||
// E.g., when duplicating NodePartner when none exists
|
||
//
|
||
if (OldStr == NULL)
|
||
return NULL;
|
||
|
||
NewStr = (PWCHAR)malloc((wcslen(OldStr) + 1) * sizeof(WCHAR));
|
||
wcscpy(NewStr, OldStr);
|
||
|
||
return NewStr;
|
||
}
|
||
|
||
|
||
|
||
|
||
VOID
|
||
AddMod(
|
||
PWCHAR AttrType,
|
||
PWCHAR AttrValue,
|
||
LDAPMod ***pppMod
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Add an attribute (plus values) to a structure that will eventually be
|
||
used in an ldap_add() function to add an object to the DS. The null-
|
||
terminated array referenced by pppMod grows with each call to this
|
||
routine. The array is freed by the caller using FreeMod().
|
||
|
||
Arguments:
|
||
AttrType - The object class of the object.
|
||
AttrValue - The value of the attribute.
|
||
pppMod - Address of an array of pointers to "attributes". Don't
|
||
give me that look -- this is an LDAP thing.
|
||
|
||
Return Value:
|
||
The pppMod array grows by one entry. The caller must free it with
|
||
FreeMod().
|
||
--*/
|
||
{
|
||
DWORD NumMod; // Number of entries in the Mod array
|
||
LDAPMod **ppMod; // Address of the first entry in the Mod array
|
||
LDAPMod *Attr; // An attribute structure
|
||
PWCHAR *Values; // An array of pointers to bervals
|
||
|
||
if (AttrValue == NULL)
|
||
return;
|
||
|
||
//
|
||
// The null-terminated array doesn't exist; create it
|
||
//
|
||
if (*pppMod == NULL) {
|
||
*pppMod = (LDAPMod **)malloc(sizeof (*pppMod));
|
||
**pppMod = NULL;
|
||
}
|
||
|
||
//
|
||
// Increase the array's size by 1
|
||
//
|
||
for (ppMod = *pppMod, NumMod = 2; *ppMod != NULL; ++ppMod, ++NumMod);
|
||
*pppMod = (LDAPMod **)realloc(*pppMod, sizeof (*pppMod) * NumMod);
|
||
|
||
//
|
||
// Add the new attribute + value to the Mod array
|
||
//
|
||
Values = (PWCHAR *)malloc(sizeof (PWCHAR) * 2);
|
||
Values[0] = _wcsdup(AttrValue);
|
||
Values[1] = NULL;
|
||
|
||
Attr = (LDAPMod *)malloc(sizeof (*Attr));
|
||
Attr->mod_values = Values;
|
||
Attr->mod_type = _wcsdup(AttrType);
|
||
// Attr->mod_op = LDAP_MOD_ADD;
|
||
Attr->mod_op = LDAP_MOD_REPLACE;
|
||
(*pppMod)[NumMod - 1] = NULL;
|
||
(*pppMod)[NumMod - 2] = Attr;
|
||
}
|
||
|
||
VOID
|
||
AddBerMod(
|
||
PWCHAR AttrType,
|
||
PCHAR AttrValue,
|
||
DWORD AttrValueLen,
|
||
LDAPMod ***pppMod
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Add an attribute (plus values) to a structure that will eventually be
|
||
used in an ldap_add() function to add an object to the DS. The null-
|
||
terminated array referenced by pppMod grows with each call to this
|
||
routine. The array is freed by the caller using FreeMod().
|
||
|
||
Arguments:
|
||
AttrType - The object class of the object.
|
||
AttrValue - The value of the attribute.
|
||
AttrValueLen - length of the attribute
|
||
pppMod - Address of an array of pointers to "attributes". Don't
|
||
give me that look -- this is an LDAP thing.
|
||
|
||
Return Value:
|
||
The pppMod array grows by one entry. The caller must free it with
|
||
FreeMod().
|
||
--*/
|
||
{
|
||
DWORD NumMod; // Number of entries in the Mod array
|
||
LDAPMod **ppMod; // Address of the first entry in the Mod array
|
||
LDAPMod *Attr; // An attribute structure
|
||
PLDAP_BERVAL Berval;
|
||
PLDAP_BERVAL *Values; // An array of pointers to bervals
|
||
|
||
if (AttrValue == NULL)
|
||
return;
|
||
|
||
//
|
||
// The null-terminated array doesn't exist; create it
|
||
//
|
||
if (*pppMod == NULL) {
|
||
*pppMod = (LDAPMod **)malloc(sizeof (*pppMod));
|
||
**pppMod = NULL;
|
||
}
|
||
|
||
//
|
||
// Increase the array's size by 1
|
||
//
|
||
for (ppMod = *pppMod, NumMod = 2; *ppMod != NULL; ++ppMod, ++NumMod);
|
||
*pppMod = (LDAPMod **)realloc(*pppMod, sizeof (*pppMod) * NumMod);
|
||
|
||
//
|
||
// Construct a berval
|
||
//
|
||
Berval = (PLDAP_BERVAL)malloc(sizeof(LDAP_BERVAL));
|
||
Berval->bv_len = AttrValueLen;
|
||
Berval->bv_val = (PCHAR)malloc(AttrValueLen);
|
||
CopyMemory(Berval->bv_val, AttrValue, AttrValueLen);
|
||
|
||
//
|
||
// Add the new attribute + value to the Mod array
|
||
//
|
||
Values = (PLDAP_BERVAL *)malloc(sizeof (PLDAP_BERVAL) * 2);
|
||
Values[0] = Berval;
|
||
Values[1] = NULL;
|
||
|
||
Attr = (LDAPMod *)malloc(sizeof (*Attr));
|
||
Attr->mod_bvalues = Values;
|
||
Attr->mod_type = _wcsdup(AttrType);
|
||
Attr->mod_op = LDAP_MOD_BVALUES | LDAP_MOD_REPLACE;
|
||
|
||
(*pppMod)[NumMod - 1] = NULL;
|
||
(*pppMod)[NumMod - 2] = Attr;
|
||
}
|
||
|
||
VOID
|
||
FreeMod(
|
||
LDAPMod ***pppMod
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Free the structure built by successive calls to AddMod().
|
||
|
||
Arguments:
|
||
pppMod - Address of a null-terminated array.
|
||
|
||
Return Value:
|
||
*pppMod set to NULL.
|
||
--*/
|
||
{
|
||
DWORD i, j;
|
||
LDAPMod **ppMod;
|
||
|
||
if (!pppMod || !*pppMod) {
|
||
return;
|
||
}
|
||
|
||
//
|
||
// For each attibute
|
||
//
|
||
ppMod = *pppMod;
|
||
for (i = 0; ppMod[i] != NULL; ++i) {
|
||
//
|
||
// For each value of the attribute
|
||
//
|
||
for (j = 0; (ppMod[i])->mod_values[j] != NULL; ++j) {
|
||
//
|
||
// Free the value
|
||
//
|
||
if (ppMod[i]->mod_op & LDAP_MOD_BVALUES) {
|
||
free(ppMod[i]->mod_bvalues[j]->bv_val);
|
||
}
|
||
free((ppMod[i])->mod_values[j]);
|
||
}
|
||
free((ppMod[i])->mod_values); // Free the array of pointers to values
|
||
free((ppMod[i])->mod_type); // Free the string identifying the attribute
|
||
free(ppMod[i]); // Free the attribute
|
||
}
|
||
free(ppMod); // Free the array of pointers to attributes
|
||
*pppMod = NULL; // Now ready for more calls to AddMod()
|
||
}
|
||
|
||
BOOL
|
||
LdapSearch(
|
||
PLDAP ldap,
|
||
PWCHAR Base,
|
||
ULONG Scope,
|
||
PWCHAR Filter,
|
||
PWCHAR Attrs[],
|
||
ULONG AttrsOnly,
|
||
LDAPMessage **Res,
|
||
BOOL Quiet
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Issue the ldap ldap_search_s call, check for errors, and check for
|
||
a shutdown in progress.
|
||
|
||
Arguments:
|
||
ldap
|
||
Base
|
||
Scope
|
||
Filter
|
||
Attrs
|
||
AttrsOnly
|
||
Res
|
||
|
||
Return Value:
|
||
The ldap array of values or NULL if the Base, DesiredAttr, or its values
|
||
does not exist. The ldap array is freed with ldap_value_free().
|
||
--*/
|
||
{
|
||
DWORD LStatus;
|
||
|
||
//
|
||
// Issue the ldap search
|
||
//
|
||
LStatus = ldap_search_s(ldap,
|
||
Base,
|
||
Scope,
|
||
Filter,
|
||
Attrs,
|
||
AttrsOnly,
|
||
Res);
|
||
//
|
||
// Check for errors
|
||
//
|
||
if (LStatus != LDAP_SUCCESS) {
|
||
if (!Quiet) {
|
||
DPRINT4("WARN - Error searching %ws for %ws; LStatus %d: %ws\n",
|
||
Base, Filter, LStatus, ldap_err2string(LStatus));
|
||
}
|
||
return FALSE;
|
||
}
|
||
//
|
||
// Return TRUE if not shutting down
|
||
//
|
||
return TRUE;
|
||
}
|
||
|
||
PWCHAR *
|
||
GetValues(
|
||
IN PLDAP Ldap,
|
||
IN PWCHAR Dn,
|
||
IN PWCHAR DesiredAttr,
|
||
IN BOOL Quiet
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Return the DS values for one attribute in an object.
|
||
|
||
Arguments:
|
||
ldap - An open, bound ldap port.
|
||
Base - The "pathname" of a DS object.
|
||
DesiredAttr - Return values for this attribute.
|
||
Quiet
|
||
|
||
Return Value:
|
||
An array of char pointers that represents the values for the attribute.
|
||
The caller must free the array with ldap_value_free(). NULL if unsuccessful.
|
||
--*/
|
||
{
|
||
PWCHAR Attr;
|
||
BerElement *Ber;
|
||
PLDAPMessage LdapMsg;
|
||
PLDAPMessage LdapEntry;
|
||
PWCHAR Attrs[2];
|
||
PWCHAR *Values = NULL;
|
||
|
||
//
|
||
// Search Base for all of its attributes + values
|
||
//
|
||
Attrs[0] = DesiredAttr;
|
||
Attrs[1] = NULL;
|
||
|
||
//
|
||
// Issue the ldap search
|
||
//
|
||
if (!LdapSearch(Ldap,
|
||
Dn,
|
||
LDAP_SCOPE_BASE,
|
||
CLASS_ANY,
|
||
Attrs,
|
||
0,
|
||
&LdapMsg,
|
||
Quiet)) {
|
||
return NULL;
|
||
}
|
||
LdapEntry = ldap_first_entry(Ldap, LdapMsg);
|
||
if (LdapEntry) {
|
||
Attr = ldap_first_attribute(Ldap, LdapEntry, &Ber);
|
||
if (Attr) {
|
||
Values = ldap_get_values(Ldap, LdapEntry, Attr);
|
||
}
|
||
}
|
||
ldap_msgfree(LdapMsg);
|
||
return Values;
|
||
}
|
||
|
||
BOOL
|
||
LdapSearchInit(
|
||
PLDAP ldap,
|
||
PWCHAR Base,
|
||
ULONG Scope,
|
||
PWCHAR Filter,
|
||
PWCHAR Attrs[],
|
||
ULONG AttrsOnly,
|
||
PFRS_LDAP_SEARCH_CONTEXT FrsSearchContext,
|
||
BOOL Quiet
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Issue the ldap ldap_search_s call, check for errors, and check for
|
||
a shutdown in progress.
|
||
|
||
Arguments:
|
||
ldap
|
||
Base
|
||
Scope
|
||
Filter
|
||
Attrs
|
||
AttrsOnly
|
||
Res
|
||
FrsSearchContext
|
||
|
||
Return Value:
|
||
The ldap array of values or NULL if the Base, DesiredAttr, or its values
|
||
does not exist. The ldap array is freed with ldap_value_free().
|
||
--*/
|
||
{
|
||
DWORD LStatus = LDAP_SUCCESS;
|
||
PLDAPControl ServerControls[2];
|
||
berval cookie1 = { 0, NULL };
|
||
|
||
FrsSearchContext->bOpen = FALSE;
|
||
FrsSearchContext->LdapMsg = NULL;
|
||
FrsSearchContext->EntriesInPage = 0;
|
||
FrsSearchContext->CurrentEntry = 0;
|
||
FrsSearchContext->TotalEntries = 0;
|
||
|
||
FrsSearchContext->Filter = FrsWcsDup(Filter);
|
||
FrsSearchContext->BaseDn = FrsWcsDup(Base);
|
||
FrsSearchContext->Scope = Scope;
|
||
FrsSearchContext->PageSize = FRS_LDAP_SEARCH_PAGESIZE;
|
||
FrsSearchContext->Attrs = Attrs;
|
||
|
||
|
||
LStatus = ldap_create_page_control(ldap,
|
||
FrsSearchContext->PageSize,
|
||
&cookie1,
|
||
FALSE, // is critical
|
||
&ServerControls[0]
|
||
);
|
||
|
||
ServerControls[1] = NULL;
|
||
|
||
if (LStatus != LDAP_SUCCESS) {
|
||
DPRINT1("ldap_create_page_control returned error. LStatus = 0x%x\n", LStatus);
|
||
}
|
||
|
||
LStatus = ldap_search_ext_s(ldap,
|
||
FrsSearchContext->BaseDn,
|
||
FrsSearchContext->Scope,
|
||
FrsSearchContext->Filter,
|
||
FrsSearchContext->Attrs,
|
||
FALSE,
|
||
ServerControls,
|
||
NULL,
|
||
NULL,
|
||
0,
|
||
&FrsSearchContext->LdapMsg);
|
||
|
||
if (LStatus == LDAP_SUCCESS) {
|
||
FrsSearchContext->EntriesInPage = ldap_count_entries(ldap, FrsSearchContext->LdapMsg);
|
||
FrsSearchContext->CurrentEntry = 0;
|
||
FrsSearchContext->bOpen = TRUE;
|
||
}
|
||
|
||
|
||
return (LStatus == LDAP_SUCCESS);
|
||
}
|
||
|
||
PLDAPMessage
|
||
LdapSearchGetNextEntry(
|
||
PLDAP ldap,
|
||
PFRS_LDAP_SEARCH_CONTEXT FrsSearchContext
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Issue the ldap ldap_search_s call, check for errors, and check for
|
||
a shutdown in progress.
|
||
|
||
Arguments:
|
||
ldap
|
||
FrsSearchContext
|
||
|
||
Return Value:
|
||
The ldap array of values or NULL if the Base, DesiredAttr, or its values
|
||
does not exist. The ldap array is freed with ldap_value_free().
|
||
--*/
|
||
{
|
||
|
||
FrsSearchContext->CurrentEntry += 1;
|
||
if ( FrsSearchContext->CurrentEntry == 1 ) {
|
||
FrsSearchContext->CurrentLdapMsg = ldap_first_entry(ldap ,FrsSearchContext->LdapMsg);
|
||
} else {
|
||
FrsSearchContext->CurrentLdapMsg = ldap_next_entry(ldap ,FrsSearchContext->CurrentLdapMsg);
|
||
}
|
||
|
||
return FrsSearchContext->CurrentLdapMsg;
|
||
}
|
||
|
||
DWORD
|
||
LdapSearchGetNextPage(
|
||
PLDAP ldap,
|
||
PFRS_LDAP_SEARCH_CONTEXT FrsSearchContext
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Issue the ldap ldap_search_s call, check for errors, and check for
|
||
a shutdown in progress.
|
||
|
||
Arguments:
|
||
ldap
|
||
FrsSearchContext
|
||
|
||
Return Value:
|
||
The ldap array of values or NULL if the Base, DesiredAttr, or its values
|
||
does not exist. The ldap array is freed with ldap_value_free().
|
||
--*/
|
||
{
|
||
DWORD LStatus = LDAP_SUCCESS;
|
||
berval * CurrCookie = NULL;
|
||
PLDAPControl * CurrControls = NULL;
|
||
ULONG retcode = 0;
|
||
PLDAPControl ServerControls[2];
|
||
|
||
|
||
|
||
// Get the server control from the message, and make a new control with the cookie from the server
|
||
LStatus = ldap_parse_result(ldap, FrsSearchContext->LdapMsg, &retcode,NULL,NULL,NULL,&CurrControls,FALSE);
|
||
ldap_msgfree(FrsSearchContext->LdapMsg);
|
||
FrsSearchContext->LdapMsg = NULL;
|
||
|
||
if (LStatus == LDAP_SUCCESS) {
|
||
LStatus = ldap_parse_page_control(ldap, CurrControls, &FrsSearchContext->TotalEntries, &CurrCookie);
|
||
// under Exchange 5.5, before SP 2, this will fail with LDAP_CONTROL_NOT_FOUND when there are
|
||
// no more search results. With Exchange 5.5 SP 2, this succeeds, and gives us a cookie that will
|
||
// cause us to start over at the beginning of the search results.
|
||
|
||
}
|
||
if (LStatus == LDAP_SUCCESS) {
|
||
if ( CurrCookie->bv_len == 0 && CurrCookie->bv_val == 0 ) {
|
||
// under Exchange 5.5, SP 2, this means we're at the end of the results.
|
||
// if we pass in this cookie again, we will start over at the beginning of the search results.
|
||
LStatus = LDAP_CONTROL_NOT_FOUND;
|
||
}
|
||
|
||
ServerControls[0] = NULL;
|
||
ServerControls[1] = NULL;
|
||
if (LStatus == LDAP_SUCCESS) {
|
||
LStatus = ldap_create_page_control(ldap,
|
||
FrsSearchContext->PageSize,
|
||
CurrCookie,
|
||
FALSE,
|
||
ServerControls);
|
||
}
|
||
ldap_controls_free(CurrControls);
|
||
CurrControls = NULL;
|
||
ber_bvfree(CurrCookie);
|
||
CurrCookie = NULL;
|
||
}
|
||
|
||
// continue the search with the new cookie
|
||
if (LStatus == LDAP_SUCCESS) {
|
||
LStatus = ldap_search_ext_s(ldap,
|
||
FrsSearchContext->BaseDn,
|
||
FrsSearchContext->Scope,
|
||
FrsSearchContext->Filter,
|
||
FrsSearchContext->Attrs,
|
||
FALSE,
|
||
ServerControls,
|
||
NULL,
|
||
NULL,
|
||
0,
|
||
&FrsSearchContext->LdapMsg);
|
||
|
||
if ( (LStatus != LDAP_SUCCESS) && (LStatus != LDAP_CONTROL_NOT_FOUND) )
|
||
{
|
||
// LDAP_CONTROL_NOT_FOUND means that we have reached the end of the search results
|
||
// in Exchange 5.5, before SP 2 (the server doesn't return a page control when there
|
||
// are no more pages, so we get LDAP_CONTROL_NOT_FOUND when we try to extract the page
|
||
// control from the search results).
|
||
|
||
}
|
||
}
|
||
|
||
if (LStatus == LDAP_SUCCESS) {
|
||
FrsSearchContext->EntriesInPage = ldap_count_entries(ldap, FrsSearchContext->LdapMsg);
|
||
FrsSearchContext->CurrentEntry = 0;
|
||
|
||
}
|
||
|
||
return LdapMapErrorToWin32(LStatus);
|
||
}
|
||
|
||
PLDAPMessage
|
||
LdapSearchNext(
|
||
PLDAP ldap,
|
||
PFRS_LDAP_SEARCH_CONTEXT FrsSearchContext
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Issue the ldap ldap_search_s call, check for errors, and check for
|
||
a shutdown in progress.
|
||
|
||
Arguments:
|
||
ldap
|
||
FrsSearchContext
|
||
|
||
Return Value:
|
||
The ldap array of values or NULL if the Base, DesiredAttr, or its values
|
||
does not exist. The ldap array is freed with ldap_value_free().
|
||
--*/
|
||
{
|
||
DWORD WStatus = ERROR_SUCCESS;
|
||
PLDAPMessage NextEntry = NULL;
|
||
|
||
if (FrsSearchContext->bOpen != TRUE)
|
||
{
|
||
NextEntry = NULL;
|
||
}
|
||
else
|
||
{
|
||
if (FrsSearchContext->EntriesInPage > FrsSearchContext->CurrentEntry )
|
||
{
|
||
// return the next entry from the current page
|
||
return LdapSearchGetNextEntry(ldap, FrsSearchContext);
|
||
}
|
||
else
|
||
{
|
||
// see if there are more pages of results to get
|
||
WStatus = LdapSearchGetNextPage(ldap, FrsSearchContext);
|
||
if (WStatus == ERROR_SUCCESS)
|
||
{
|
||
return LdapSearchGetNextEntry(ldap, FrsSearchContext);
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
|
||
return NextEntry;
|
||
}
|
||
|
||
VOID
|
||
LdapSearchClose(
|
||
PFRS_LDAP_SEARCH_CONTEXT FrsSearchContext
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Issue the ldap ldap_search_s call, check for errors, and check for
|
||
a shutdown in progress.
|
||
|
||
Arguments:
|
||
ldap
|
||
FrsSearchContext
|
||
|
||
Return Value:
|
||
The ldap array of values or NULL if the Base, DesiredAttr, or its values
|
||
does not exist. The ldap array is freed with ldap_value_free().
|
||
--*/
|
||
{
|
||
FrsSearchContext->bOpen = FALSE;
|
||
FrsSearchContext->EntriesInPage = 0;
|
||
FrsSearchContext->CurrentEntry = 0;
|
||
FrsSearchContext->TotalEntries = 0;
|
||
|
||
FREE(FrsSearchContext->Filter);
|
||
FREE(FrsSearchContext->BaseDn);
|
||
|
||
if (FrsSearchContext->LdapMsg != NULL) {
|
||
ldap_msgfree(FrsSearchContext->LdapMsg);
|
||
}
|
||
}
|
||
|
||
PWCHAR
|
||
GetRootDn(
|
||
PLDAP Ldap,
|
||
PWCHAR NamingContext
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
|
||
Arguments:
|
||
|
||
Return Value:
|
||
--*/
|
||
{
|
||
PWCHAR Root; // DS pathname of configuration container
|
||
PWCHAR *Values; // values from the attribute "namingContexts"
|
||
DWORD NumVals; // number of values
|
||
|
||
//
|
||
// Return all of the values for the attribute namingContexts
|
||
//
|
||
Values = GetValues(Ldap, ATTR_ROOT, ATTR_NAMING_CONTEXTS, FALSE);
|
||
if (Values == NULL)
|
||
return NULL;
|
||
|
||
//
|
||
// Find the naming context that begins with CN=Configuration
|
||
//
|
||
NumVals = ldap_count_values(Values);
|
||
while (NumVals--) {
|
||
Root = wcsstr(Values[NumVals], NamingContext);
|
||
if (Root != NULL && Root == Values[NumVals]) {
|
||
Root = FrsWcsDup(Root);
|
||
ldap_value_free(Values);
|
||
return Root;
|
||
}
|
||
}
|
||
DPRINT1("ERROR - COULD NOT FIND %ws\n", NamingContext);
|
||
ldap_value_free(Values);
|
||
return NULL;
|
||
}
|
||
|
||
PWCHAR
|
||
ExtendDn(
|
||
PWCHAR Dn,
|
||
PWCHAR Cn
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Extend an existing DN with a new CN= component.
|
||
|
||
Arguments:
|
||
Dn - distinguished name
|
||
Cn - common name
|
||
|
||
Return Value:
|
||
CN=Cn,Dn
|
||
--*/
|
||
{
|
||
ULONG Len;
|
||
PWCHAR NewDn;
|
||
|
||
Len = wcslen(L"CN=,") + wcslen(Dn) + wcslen(Cn) + 1;
|
||
NewDn = (PWCHAR)malloc(Len * sizeof(WCHAR));
|
||
wcscpy(NewDn, L"CN=");
|
||
wcscat(NewDn, Cn);
|
||
wcscat(NewDn, L",");
|
||
wcscat(NewDn, Dn);
|
||
return NewDn;
|
||
}
|
||
|
||
PVOID *
|
||
FindValues(
|
||
PLDAPMessage LdapEntry,
|
||
PWCHAR DesiredAttr,
|
||
BOOL DoBerValues
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Return the DS values for one attribute in an entry.
|
||
|
||
Arguments:
|
||
Ldap - An open, bound ldap port.
|
||
LdapEntry - An ldap entry returned by ldap_search_s()
|
||
DesiredAttr - Return values for this attribute.
|
||
DoVerValues - Return the bervals
|
||
|
||
Return Value:
|
||
An array of char pointers that represents the values for the attribute.
|
||
The caller must free the array with ldap_value_free(). NULL if unsuccessful.
|
||
--*/
|
||
{
|
||
PWCHAR LdapAttr; // Retrieved from an ldap entry
|
||
BerElement *Ber; // Needed for scanning attributes
|
||
|
||
//
|
||
// Search the entry for the desired attribute
|
||
//
|
||
for (LdapAttr = ldap_first_attribute(pLdap, LdapEntry, &Ber);
|
||
LdapAttr != NULL;
|
||
LdapAttr = ldap_next_attribute(pLdap, LdapEntry, Ber)) {
|
||
if (_wcsicmp(DesiredAttr, LdapAttr) == 0) {
|
||
//
|
||
// Return the values for DesiredAttr
|
||
//
|
||
if (DoBerValues) {
|
||
return (PVOID *)ldap_get_values_len(pLdap, LdapEntry, LdapAttr);
|
||
} else {
|
||
return (PVOID *)ldap_get_values(pLdap, LdapEntry, LdapAttr);
|
||
}
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
PWCHAR
|
||
FindValue(
|
||
PLDAPMessage LdapEntry,
|
||
PWCHAR DesiredAttr
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Return a copy of the first DS value for one attribute in an entry.
|
||
|
||
Arguments:
|
||
Ldap - An open, bound ldap port.
|
||
LdapEntry - An ldap entry returned by ldap_search_s()
|
||
DesiredAttr - Return values for this attribute.
|
||
|
||
Return Value:
|
||
A zero-terminated string or NULL if the attribute or its value
|
||
doesn't exist. The string is freed with FREE().
|
||
--*/
|
||
{
|
||
PWCHAR Val;
|
||
PWCHAR *Values;
|
||
|
||
// Get ldap's array of values
|
||
Values = (PWCHAR *)FindValues(LdapEntry, DesiredAttr, FALSE);
|
||
|
||
// Copy the first value (if any)
|
||
if (Values) {
|
||
Val = new WCHAR[wcslen(Values[0]) + 1];
|
||
wcscpy(Val, Values[0]);
|
||
} else {
|
||
Val = NULL;
|
||
}
|
||
|
||
// Free ldap's array of values
|
||
ldap_value_free(Values);
|
||
|
||
return Val;
|
||
}
|
||
|
||
BOOL
|
||
FindBerValue(
|
||
PLDAPMessage Entry,
|
||
PWCHAR DesiredAttr,
|
||
ULONG *Len,
|
||
VOID **Value
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Return a copy of the attributes object's schedule
|
||
|
||
Arguments:
|
||
ldap - An open, bound ldap port.
|
||
Entry - An ldap entry returned by ldap_search_s()
|
||
DesiredAttr - desired attribute
|
||
Len - length of Value
|
||
Value - binary value
|
||
|
||
Return Value:
|
||
The address of a schedule or NULL. Free with FrsFree().
|
||
--*/
|
||
{
|
||
PLDAP_BERVAL *Values;
|
||
|
||
*Len = 0;
|
||
*Value = NULL;
|
||
|
||
//
|
||
// Get ldap's array of values
|
||
//
|
||
Values = (PLDAP_BERVAL *)FindValues(Entry, DesiredAttr, TRUE);
|
||
if (!Values) {
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Return a copy of the schedule
|
||
//
|
||
*Len = Values[0]->bv_len;
|
||
if (*Len) {
|
||
*Value = new WCHAR[*Len];
|
||
CopyMemory(*Value, Values[0]->bv_val, *Len);
|
||
}
|
||
ldap_value_free_len(Values);
|
||
return TRUE;
|
||
}
|
||
|
||
DWORD
|
||
FormMemberDn(
|
||
IN PWCHAR ReplicaSetName,
|
||
IN PWCHAR ComputerDnsName,
|
||
OUT PWCHAR *pMemberDn
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Form the member Dn given the computername and the replica set name.
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS - Success
|
||
|
||
--*/
|
||
{
|
||
DWORD Status = ERROR_SUCCESS;
|
||
WCHAR SearchFilter[MAX_PATH];
|
||
ULONG NoOfSets = 0;
|
||
PLDAPMessage LdapEntry = NULL;
|
||
PWCHAR ConfigDn = NULL;
|
||
PWCHAR ServicesDn = NULL;
|
||
PWCHAR FrsTestDn = NULL;
|
||
PWCHAR DomainDn = NULL;
|
||
PWCHAR SystemDn = NULL;
|
||
PWCHAR FrsDn = NULL;
|
||
PWCHAR SetDn = NULL;
|
||
PWCHAR MemberDn = NULL;
|
||
PWCHAR ComputerDn = NULL;
|
||
PWCHAR *Values = NULL;
|
||
PWCHAR Attrs[3];
|
||
PWCHAR Attrs2[4];
|
||
FRS_LDAP_SEARCH_CONTEXT FrsSearchContext;
|
||
|
||
Attrs[0] = ATTR_DN;
|
||
Attrs[1] = ATTR_CN;
|
||
Attrs[2] = NULL;
|
||
|
||
|
||
|
||
DomainDn = GetRootDn(pLdap, DOMAIN_NAMING_CONTEXT);
|
||
if (DomainDn == NULL) {
|
||
return MKDSXE_NO_T0_NTDS_SETTINGS;
|
||
}
|
||
|
||
SystemDn = ExtendDn(DomainDn, CN_SYSTEM);
|
||
FrsDn = ExtendDn(SystemDn, CN_NTFRS_SETTINGS);
|
||
|
||
wcscpy(SearchFilter, L"(&(");
|
||
wcscat(SearchFilter, ATTR_CN);
|
||
wcscat(SearchFilter, L"=");
|
||
wcscat(SearchFilter, ReplicaSetName);
|
||
wcscat(SearchFilter, L")");
|
||
wcscat(SearchFilter, CLASS_NTFRS_REPLICA_SET);
|
||
wcscat(SearchFilter, L")");
|
||
|
||
if (!LdapSearchInit(pLdap,
|
||
FrsDn,
|
||
LDAP_SCOPE_SUBTREE,
|
||
SearchFilter,
|
||
Attrs,
|
||
0,
|
||
&FrsSearchContext,
|
||
FALSE)) {
|
||
Status = MKDSXE_NO_T0_NTDS_SETTINGS ;
|
||
goto RETURN;
|
||
}
|
||
|
||
NoOfSets = FrsSearchContext.EntriesInPage;
|
||
|
||
if (NoOfSets == 0) {
|
||
|
||
LdapSearchClose(&FrsSearchContext);
|
||
|
||
//
|
||
// Replica set was not found under system. Look under
|
||
// CN=NTFRS Test Settings,CN=Services,CN=Configuration,DC=...
|
||
//
|
||
ConfigDn = GetRootDn(pLdap, CONFIG_NAMING_CONTEXT);
|
||
if (ConfigDn == NULL) {
|
||
Status = MKDSXE_NO_T0_NTDS_SETTINGS;
|
||
goto RETURN;
|
||
}
|
||
ServicesDn = ExtendDn(ConfigDn, CN_SERVICES);
|
||
FrsTestDn = ExtendDn(ServicesDn, CN_TEST_SETTINGS);
|
||
|
||
if (!LdapSearchInit(pLdap,
|
||
FrsTestDn,
|
||
LDAP_SCOPE_SUBTREE,
|
||
SearchFilter,
|
||
Attrs,
|
||
0,
|
||
&FrsSearchContext,
|
||
FALSE)) {
|
||
Status = MKDSXE_NO_T0_NTDS_SETTINGS ;
|
||
goto RETURN;
|
||
}
|
||
|
||
NoOfSets = FrsSearchContext.EntriesInPage;
|
||
}
|
||
|
||
|
||
if (NoOfSets != 1) {
|
||
DPRINT0("Error finding replica set.\n");
|
||
return MKDSXE_NO_T0_NTDS_SETTINGS;
|
||
}
|
||
|
||
//
|
||
// Scan the entries returned from ldap_search
|
||
//
|
||
for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext);
|
||
LdapEntry != NULL;
|
||
LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) {
|
||
|
||
SetDn = FindValue(LdapEntry, ATTR_DN);
|
||
}
|
||
|
||
DPRINT1("Replica Set Dn:%ws\n", SetDn);
|
||
|
||
LdapSearchClose(&FrsSearchContext);
|
||
|
||
Attrs2[0] = ATTR_DN;
|
||
Attrs2[1] = ATTR_CN;
|
||
Attrs2[2] = ATTR_COMPUTER_REF;
|
||
Attrs2[3] = NULL;
|
||
|
||
if (!LdapSearchInit(pLdap,
|
||
SetDn,
|
||
LDAP_SCOPE_ONELEVEL,
|
||
CLASS_MEMBER,
|
||
Attrs2,
|
||
0,
|
||
&FrsSearchContext,
|
||
FALSE)) {
|
||
Status = MKDSXE_NO_T0_NTDS_SETTINGS;
|
||
goto RETURN;
|
||
}
|
||
|
||
//
|
||
// Scan the entries returned from ldap_search
|
||
//
|
||
for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext);
|
||
LdapEntry != NULL;
|
||
LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) {
|
||
|
||
MemberDn = FindValue(LdapEntry, ATTR_DN);
|
||
ComputerDn = FindValue(LdapEntry, ATTR_COMPUTER_REF);
|
||
if (ComputerDn != NULL) {
|
||
Values = GetValues(pLdap, ComputerDn, ATTR_DNS_HOST_NAME, TRUE);
|
||
FREE(ComputerDn);
|
||
if ((Values != NULL) && (Values[0] != NULL) && !_wcsicmp(Values[0], ComputerDnsName)) {
|
||
ldap_value_free(Values);
|
||
*pMemberDn = FrsWcsDup(MemberDn);
|
||
FREE(MemberDn);
|
||
break;
|
||
}
|
||
}
|
||
FREE(MemberDn);
|
||
}
|
||
|
||
if (*pMemberDn == NULL) {
|
||
Status = MKDSXE_NO_T0_NTDS_SETTINGS;
|
||
}
|
||
LdapSearchClose(&FrsSearchContext);
|
||
|
||
RETURN:
|
||
|
||
FREE(SetDn);
|
||
FREE(FrsDn);
|
||
FREE(SystemDn);
|
||
FREE(DomainDn);
|
||
FREE(FrsTestDn);
|
||
FREE(ServicesDn);
|
||
FREE(ConfigDn);
|
||
return Status;
|
||
}
|
||
|
||
DWORD
|
||
FormNTDSSettingsDn(
|
||
IN PWCHAR ToSite,
|
||
IN PWCHAR ToServer,
|
||
OUT PWCHAR *pNTDSSettingsDn
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Form the settings dn for the to server.
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS - Success
|
||
|
||
--*/
|
||
{
|
||
DWORD Status = ERROR_SUCCESS;
|
||
PWCHAR ConfigDn = NULL;
|
||
PWCHAR SitesDn = NULL;
|
||
PWCHAR ToSiteDn = NULL;
|
||
PWCHAR ServersDn = NULL;
|
||
PWCHAR ToServerDn = NULL;
|
||
PWCHAR Attrs[2];
|
||
PLDAPMessage LdapMsg;
|
||
|
||
Attrs[0] = ATTR_DN;
|
||
Attrs[1] = NULL;
|
||
|
||
|
||
ConfigDn = GetRootDn(pLdap, CONFIG_NAMING_CONTEXT);
|
||
if (ConfigDn == NULL) {
|
||
return MKDSXE_NO_T0_NTDS_SETTINGS;
|
||
}
|
||
|
||
SitesDn = ExtendDn(ConfigDn, CN_SITES);
|
||
ToSiteDn = ExtendDn(SitesDn, ToSite);
|
||
ServersDn = ExtendDn(ToSiteDn, L"Servers");
|
||
ToServerDn = ExtendDn(ServersDn, ToServer);
|
||
*pNTDSSettingsDn = ExtendDn(ToServerDn, L"NTDS Settings");
|
||
|
||
if (!LdapSearch(pLdap,
|
||
*pNTDSSettingsDn,
|
||
LDAP_SCOPE_BASE,
|
||
CLASS_NTDS_SETTINGS,
|
||
Attrs,
|
||
0,
|
||
&LdapMsg,
|
||
TRUE)){
|
||
Status = MKDSXE_NO_T0_NTDS_SETTINGS;
|
||
}
|
||
|
||
|
||
FREE(ConfigDn);
|
||
FREE(SitesDn);
|
||
FREE(ToSiteDn);
|
||
FREE(ServersDn);
|
||
FREE(ToServerDn);
|
||
ldap_msgfree(LdapMsg);
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
PBYTE
|
||
ReadScheduleFile(
|
||
PWCHAR FileName
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Read a Hex formated byte array for a 7x24 schedule from a file.
|
||
Convert to a 7x24 binary schedule.
|
||
|
||
Arguments:
|
||
FileName - Name of schedule file.
|
||
|
||
Return Value:
|
||
ptr to schedule data array or NULL if invalid param.
|
||
--*/
|
||
{
|
||
HANDLE FileHandle;
|
||
PBYTE SchedData;
|
||
DWORD WStatus;
|
||
DWORD BytesRead;
|
||
DWORD DataByte, i, Day, Hour;
|
||
ULONG Remaining;
|
||
PCHAR pTC;
|
||
CHAR SchedText[FRST_SIZE_OF_SCHEDULE_GRID*3 + 50];
|
||
|
||
SchedData = new BYTE[FRST_SIZE_OF_SCHEDULE_GRID];
|
||
if (SchedData == NULL) {
|
||
printf("Error allocating memory.\n");
|
||
return NULL;
|
||
}
|
||
|
||
FileHandle = CreateFileW(
|
||
FileName, // lpszName
|
||
GENERIC_READ | GENERIC_WRITE, // fdwAccess
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE, // fdwShareMode
|
||
NULL, // lpsa
|
||
OPEN_EXISTING, // fdwCreate
|
||
FILE_ATTRIBUTE_NORMAL, // fdwAttrAndFlags
|
||
NULL); // hTemplateFile
|
||
|
||
if (!HANDLE_IS_VALID(FileHandle)) {
|
||
WStatus = GetLastError();
|
||
printf("Error opening %ws WStatus: %d\n", FileName, WStatus);
|
||
FREE(SchedData);
|
||
return NULL;
|
||
}
|
||
|
||
if (!ReadFile(FileHandle, SchedText, sizeof(SchedText), &BytesRead, NULL)) {
|
||
WStatus = GetLastError();
|
||
printf("Error reading %ws WStatus: %d\n", FileName, WStatus);
|
||
FREE(SchedData);
|
||
FRS_CLOSE(FileHandle);
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// remove any white-space chars, including CR-LF, used for formatting.
|
||
//
|
||
Remaining = BytesRead;
|
||
pTC = SchedText;
|
||
|
||
while (Remaining > 0) {
|
||
if (isspace((LONG) *pTC)) {
|
||
memcpy(pTC, pTC+1, Remaining-1);
|
||
} else {
|
||
pTC++;
|
||
}
|
||
Remaining -= 1;
|
||
}
|
||
BytesRead = pTC - SchedText;
|
||
|
||
if (BytesRead < FRST_SIZE_OF_SCHEDULE_GRID*2) {
|
||
printf("Error reading %ws Expecting %d bytes, Actual was %d bytes. Could be too much whitespace.\n",
|
||
FileName, FRST_SIZE_OF_SCHEDULE_GRID*2, BytesRead);
|
||
FREE(SchedData);
|
||
FRS_CLOSE(FileHandle);
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// Result should be exactly the right size.
|
||
//
|
||
if (BytesRead != FRST_SIZE_OF_SCHEDULE_GRID*2) {
|
||
printf("Error reading %ws Expecting %d bytes, Actual was %d bytes\n",
|
||
FileName, FRST_SIZE_OF_SCHEDULE_GRID*2, BytesRead);
|
||
FREE(SchedData);
|
||
FRS_CLOSE(FileHandle);
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// Convert to binary.
|
||
//
|
||
for (i=0; i<FRST_SIZE_OF_SCHEDULE_GRID; i++) {
|
||
if (sscanf(&SchedText[i*2], "%2x", &DataByte) != 1) {
|
||
SchedText[i*2+2] = '\0';
|
||
printf("Error reading %ws Invalid hex data (%s) for schedule byte %d.\n",
|
||
FileName, &SchedText[i*2], i);
|
||
FREE(SchedData);
|
||
FRS_CLOSE(FileHandle);
|
||
return NULL;
|
||
}
|
||
SchedData[i] = (BYTE) DataByte;
|
||
}
|
||
|
||
|
||
FRS_CLOSE(FileHandle);
|
||
return SchedData;
|
||
}
|
||
|
||
DWORD
|
||
BuildSchedule(
|
||
PBYTE *ppSchedule,
|
||
DWORD Interval,
|
||
DWORD Stagger,
|
||
DWORD Offset
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Build the schedule structure.
|
||
Arguments:
|
||
ppSchedule - pointer to return the schedule in.
|
||
|
||
Return Value:
|
||
winerror.
|
||
--*/
|
||
{
|
||
BYTE ScheduleData[FRST_SIZE_OF_SCHEDULE_GRID];
|
||
UINT i, Day, Hour;
|
||
DWORD Status = ERROR_SUCCESS;
|
||
|
||
*ppSchedule = new BYTE[FRST_SIZE_OF_SCHEDULE];
|
||
if (*ppSchedule == NULL) {
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
//
|
||
// Set the values for the elements of the SCHEDULE structure.
|
||
//
|
||
|
||
((PSCHEDULE)*ppSchedule)->Size = FRST_SIZE_OF_SCHEDULE;
|
||
((PSCHEDULE)*ppSchedule)->Bandwidth = 0;
|
||
((PSCHEDULE)*ppSchedule)->NumberOfSchedules = 1;
|
||
((PSCHEDULE)*ppSchedule)->Schedules->Type = SCHEDULE_INTERVAL;
|
||
((PSCHEDULE)*ppSchedule)->Schedules->Offset = sizeof(SCHEDULE);
|
||
|
||
//
|
||
// Building the ScheduleData array depending on the requested schedule.
|
||
//
|
||
|
||
for (i=0 ; i<FRST_SIZE_OF_SCHEDULE_GRID ; ++i) {
|
||
if (Interval == 0) {
|
||
ScheduleData[i] = 0x00;
|
||
} else if (i < (Offset*Interval)) {
|
||
ScheduleData[i] = 0x00;
|
||
} else if ((i-(Offset*Interval))%(Interval * Stagger) == 0) {
|
||
ScheduleData[i] = 0x01;
|
||
} else {
|
||
ScheduleData[i] = 0x00;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Use the supplied schedule mask to turn off regions of the above schedule.
|
||
//
|
||
if (SchedMask != NULL) {
|
||
for (i=0 ; i<FRST_SIZE_OF_SCHEDULE_GRID ; ++i) {
|
||
ScheduleData[i] &= ~SchedMask[i];
|
||
}
|
||
}
|
||
|
||
//
|
||
// Apply the supplied override schedule to regions of the above schedule.
|
||
//
|
||
if (SchedOverride != NULL) {
|
||
for (i=0 ; i<FRST_SIZE_OF_SCHEDULE_GRID ; ++i) {
|
||
ScheduleData[i] |= SchedOverride[i];
|
||
}
|
||
}
|
||
|
||
memcpy((*ppSchedule)+sizeof(SCHEDULE),ScheduleData, FRST_SIZE_OF_SCHEDULE_GRID);
|
||
return Status;
|
||
}
|
||
|
||
DWORD
|
||
UpdateConnection(
|
||
PWCHAR FromNTDSSettingsDn,
|
||
PWCHAR ToNTDSSettingsDn,
|
||
BOOL bEnabled,
|
||
DWORD Options,
|
||
PBYTE pSchedule
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Update the connection parameters.
|
||
Arguments:
|
||
|
||
Return Value:
|
||
--*/
|
||
{
|
||
LDAPMod **Mod = NULL;
|
||
DWORD LStatus = LDAP_SUCCESS;
|
||
DWORD Status = ERROR_SUCCESS;
|
||
PWCHAR CxtionDn = NULL;
|
||
PWCHAR Attrs[6];
|
||
PLDAPMessage LdapMsg = NULL;
|
||
PLDAPMessage LdapEntry = NULL;
|
||
WCHAR SearchFilter[MAX_PATH];
|
||
PWCHAR CurEnabled = NULL;
|
||
DWORD NoOfCxtions;
|
||
PSCHEDULE Schedule = NULL;
|
||
DWORD ScheduleLen;
|
||
BOOL bNeedsUpdate = FALSE;
|
||
FRS_LDAP_SEARCH_CONTEXT FrsSearchContext;
|
||
WCHAR OptionsStr[10];
|
||
PWCHAR OptionsVal = NULL;
|
||
UINT i;
|
||
|
||
|
||
Attrs[0] = ATTR_DN;
|
||
Attrs[1] = ATTR_FROM_SERVER;
|
||
Attrs[2] = ATTR_ENABLED_CXTION;
|
||
Attrs[3] = ATTR_SCHEDULE;
|
||
Attrs[4] = ATTR_OPTIONS;
|
||
Attrs[5] = NULL;
|
||
|
||
wcscpy(SearchFilter, L"(&(");
|
||
wcscat(SearchFilter, ATTR_FROM_SERVER);
|
||
wcscat(SearchFilter, L"=");
|
||
wcscat(SearchFilter, FromNTDSSettingsDn);
|
||
wcscat(SearchFilter, L")");
|
||
wcscat(SearchFilter, CLASS_CXTION);
|
||
wcscat(SearchFilter, L")");
|
||
|
||
if (!LdapSearchInit(pLdap,
|
||
ToNTDSSettingsDn,
|
||
LDAP_SCOPE_ONELEVEL,
|
||
SearchFilter,
|
||
Attrs,
|
||
0,
|
||
&FrsSearchContext,
|
||
FALSE)) {
|
||
return MKDSXE_CXTION_OBJ_UPDATE_FAILED;
|
||
}
|
||
|
||
NoOfCxtions = FrsSearchContext.EntriesInPage;
|
||
|
||
if (NoOfCxtions == 0) {
|
||
DPRINT0("Error updating; connection not found.\n");
|
||
return MKDSXE_CXTION_NOT_FOUND_UPDATE;
|
||
}
|
||
|
||
if (NoOfCxtions > 1) {
|
||
DPRINT0("Error updating; duplicate connections found.\n");
|
||
return MKDSXE_CXTION_DUPS_FOUND_UPDATE;
|
||
}
|
||
|
||
//
|
||
// Scan the entries returned from ldap_search
|
||
//
|
||
for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext);
|
||
LdapEntry != NULL;
|
||
LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) {
|
||
|
||
CxtionDn = FindValue(LdapEntry, ATTR_DN);
|
||
CurEnabled = FindValue(LdapEntry, ATTR_ENABLED_CXTION);
|
||
OptionsVal = FindValue(LdapEntry, ATTR_OPTIONS);
|
||
FindBerValue(LdapEntry, ATTR_SCHEDULE, &ScheduleLen, (VOID **)&Schedule);
|
||
|
||
}
|
||
|
||
LdapSearchClose(&FrsSearchContext);
|
||
|
||
DPRINT1("Connection Dn:%ws\n", CxtionDn);
|
||
// Check ATTR_ENABLED_CXTION
|
||
if (bEnabled) {
|
||
if ((CurEnabled == NULL) || wcscmp(CurEnabled, ATTR_TRUE)) {
|
||
AddMod(ATTR_ENABLED_CXTION, ATTR_TRUE, &Mod);
|
||
bNeedsUpdate = TRUE;
|
||
DPRINT0(" New enabledCxtion:TRUE\n");
|
||
}
|
||
} else {
|
||
if ((CurEnabled == NULL) || wcscmp(CurEnabled, ATTR_FALSE)) {
|
||
AddMod(ATTR_ENABLED_CXTION, ATTR_FALSE, &Mod);
|
||
bNeedsUpdate = TRUE;
|
||
DPRINT0(" New enabledCxtion:FALSE\n");
|
||
}
|
||
}
|
||
|
||
// Check ATTR_OPTIONS
|
||
if (_wtoi(OptionsVal) != Options) {
|
||
|
||
_itow(Options, OptionsStr, 10);
|
||
|
||
AddMod(ATTR_OPTIONS, OptionsStr, &Mod);
|
||
DPRINT1(" options:%ws [ ", OptionsStr);
|
||
for (i = 1 ; i<5;++i) {
|
||
if (NtdsConnOptions[i] & Options) {
|
||
DPRINT1("%ws ", NtdsConnOptionsStr[i]);
|
||
}
|
||
}
|
||
DPRINT0("]\n");
|
||
bNeedsUpdate = TRUE;
|
||
}
|
||
|
||
FREE(OptionsVal);
|
||
|
||
// Check ATTR_SCHEDULE
|
||
if (pSchedule != NULL) {
|
||
if ((Schedule == NULL) ||
|
||
(FRST_SIZE_OF_SCHEDULE != ScheduleLen) ||
|
||
(memcmp(Schedule, pSchedule, FRST_SIZE_OF_SCHEDULE))) {
|
||
bNeedsUpdate = TRUE;
|
||
AddBerMod(ATTR_SCHEDULE,(PCHAR)pSchedule,FRST_SIZE_OF_SCHEDULE,&Mod);
|
||
|
||
DPRINT0(" New schedule:\n");
|
||
PrintSchedule((PSCHEDULE)pSchedule, 0x0F);
|
||
}
|
||
}
|
||
|
||
if (bNeedsUpdate) {
|
||
if (bDebugMode) {
|
||
DPRINT1("LStatus = ldap_modify_s(pLdap, %ws, Mod);\n", CxtionDn);
|
||
} else {
|
||
LStatus = ldap_modify_s(pLdap, CxtionDn, Mod);
|
||
if (LStatus != LDAP_SUCCESS) {
|
||
DPRINT2("ERROR - Can't update %ws: %ws\n",
|
||
CxtionDn, ldap_err2string(LStatus));
|
||
Status = MKDSXE_CXTION_OBJ_UPDATE_FAILED;
|
||
}
|
||
}
|
||
|
||
} else {
|
||
DPRINT0("No update required\n");
|
||
}
|
||
|
||
FREE(CxtionDn);
|
||
FREE(CurEnabled);
|
||
FREE(Schedule);
|
||
FreeMod(&Mod);
|
||
return Status;
|
||
}
|
||
|
||
DWORD
|
||
CreateNewConnection(
|
||
PWCHAR CxtionName,
|
||
PWCHAR FromNTDSSettingsDn,
|
||
PWCHAR ToNTDSSettingsDn,
|
||
BOOL bEnabled,
|
||
DWORD Options,
|
||
PBYTE pSchedule
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Create a new connection.
|
||
Arguments:
|
||
|
||
Return Value:
|
||
--*/
|
||
{
|
||
LDAPMod **Mod = NULL;
|
||
DWORD LStatus = LDAP_SUCCESS;
|
||
DWORD Status = ERROR_SUCCESS;
|
||
PWCHAR CxtionDn = NULL;
|
||
WCHAR OptionsStr[10];
|
||
UINT i;
|
||
|
||
CxtionDn = ExtendDn(ToNTDSSettingsDn, CxtionName);
|
||
|
||
DPRINT1("Connection Dn:%ws\n", CxtionDn);
|
||
AddMod(ATTR_CLASS, ATTR_CXTION, &Mod);
|
||
AddMod(ATTR_FROM_SERVER, FromNTDSSettingsDn, &Mod);
|
||
DPRINT1(" fromServer:%ws\n", FromNTDSSettingsDn);
|
||
|
||
if (bEnabled) {
|
||
AddMod(ATTR_ENABLED_CXTION, ATTR_TRUE, &Mod);
|
||
DPRINT0(" enabledCxtion:TRUE\n");
|
||
} else {
|
||
AddMod(ATTR_ENABLED_CXTION, ATTR_FALSE, &Mod);
|
||
DPRINT0(" enabledCxtion:FALSE\n");
|
||
}
|
||
|
||
//
|
||
// If options are specified then use that options otherwise
|
||
// set options to 0.
|
||
//
|
||
if (Options == 0xffffffff) {
|
||
Options = 0;
|
||
}
|
||
|
||
_itow(Options, OptionsStr, 10);
|
||
|
||
AddMod(ATTR_OPTIONS, OptionsStr, &Mod);
|
||
DPRINT1(" options:%ws [ ", OptionsStr);
|
||
for (i = 1 ; i<5;++i) {
|
||
if (NtdsConnOptions[i] & Options) {
|
||
DPRINT1("%ws ", NtdsConnOptionsStr[i]);
|
||
}
|
||
}
|
||
DPRINT0("]\n");
|
||
|
||
if (pSchedule != NULL) {
|
||
AddBerMod(ATTR_SCHEDULE,(PCHAR)pSchedule,FRST_SIZE_OF_SCHEDULE,&Mod);
|
||
|
||
PrintSchedule((PSCHEDULE)pSchedule, 0x0F);
|
||
}
|
||
|
||
if (bDebugMode) {
|
||
DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", CxtionDn);
|
||
} else {
|
||
LStatus = ldap_add_s(pLdap, CxtionDn, Mod);
|
||
|
||
if (LStatus == LDAP_ALREADY_EXISTS) {
|
||
//
|
||
// If the object already exists then convert the create to an update.
|
||
// This is to allow the user to run the data file with creates twice without
|
||
// generating errors but only fixing the cxtions that have changed.
|
||
//
|
||
Status = UpdateConnection(FromNTDSSettingsDn, ToNTDSSettingsDn, bEnabled, Options, pSchedule);
|
||
} else if (LStatus != LDAP_SUCCESS) {
|
||
DPRINT2("ERROR - Can't create %ws: %ws\n",
|
||
CxtionDn, ldap_err2string(LStatus));
|
||
Status = MKDSXE_CXTION_OBJ_CRE_FAILED;
|
||
}
|
||
}
|
||
|
||
|
||
FREE(CxtionDn);
|
||
FreeMod(&Mod);
|
||
return Status;
|
||
}
|
||
|
||
DWORD
|
||
DelConnection(
|
||
PWCHAR FromNTDSSettingsDn,
|
||
PWCHAR ToNTDSSettingsDn
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Create a new connection.
|
||
Arguments:
|
||
|
||
Return Value:
|
||
--*/
|
||
{
|
||
DWORD LStatus = LDAP_SUCCESS;
|
||
DWORD Status = ERROR_SUCCESS;
|
||
PWCHAR CxtionDn = NULL;
|
||
PWCHAR Attrs[3];
|
||
PLDAPMessage LdapMsg = NULL;
|
||
PLDAPMessage LdapEntry = NULL;
|
||
WCHAR SearchFilter[MAX_PATH];
|
||
FRS_LDAP_SEARCH_CONTEXT FrsSearchContext;
|
||
DWORD NoOfCxtions;
|
||
|
||
Attrs[0] = ATTR_DN;
|
||
Attrs[1] = ATTR_FROM_SERVER;
|
||
Attrs[2] = NULL;
|
||
|
||
if (bAffectAll) {
|
||
wcscpy(SearchFilter, CLASS_CXTION);
|
||
} else {
|
||
wcscpy(SearchFilter, L"(&(");
|
||
wcscat(SearchFilter, ATTR_FROM_SERVER);
|
||
wcscat(SearchFilter, L"=");
|
||
wcscat(SearchFilter, FromNTDSSettingsDn);
|
||
wcscat(SearchFilter, L")");
|
||
wcscat(SearchFilter, CLASS_CXTION);
|
||
wcscat(SearchFilter, L")");
|
||
}
|
||
|
||
if (!LdapSearchInit(pLdap,
|
||
ToNTDSSettingsDn,
|
||
LDAP_SCOPE_ONELEVEL,
|
||
SearchFilter,
|
||
Attrs,
|
||
0,
|
||
&FrsSearchContext,
|
||
FALSE)) {
|
||
return MKDSXE_CXTION_DELETE_FAILED;
|
||
}
|
||
|
||
NoOfCxtions = FrsSearchContext.EntriesInPage;
|
||
|
||
if (NoOfCxtions == 0) {
|
||
DPRINT0("Warning deleting; connection not found.\n");
|
||
return MKDSXE_CXTION_NOT_FOUND_DELETE;
|
||
}
|
||
|
||
if (bAffectAll != TRUE) {
|
||
if (NoOfCxtions > 1) {
|
||
DPRINT0("Duplicate connections found. Deleting all.\n");
|
||
Status = MKDSXE_MULTIPLE_CXTIONS_DELETED;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Scan the entries returned from ldap_search
|
||
//
|
||
for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext);
|
||
LdapEntry != NULL;
|
||
LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) {
|
||
|
||
CxtionDn = FindValue(LdapEntry, ATTR_DN);
|
||
DPRINT1("Deleting Dn:%ws\n", CxtionDn);
|
||
if (bDebugMode) {
|
||
DPRINT1("LStatus = ldap_delete_s(pLdap, %ws);\n", CxtionDn);
|
||
} else {
|
||
LStatus = ldap_delete_s(pLdap, CxtionDn);
|
||
if (LStatus != LDAP_SUCCESS) {
|
||
DPRINT2("ERROR - Can't delete %ws: %ws\n",
|
||
CxtionDn, ldap_err2string(LStatus));
|
||
Status = MKDSXE_CXTION_DELETE_FAILED;
|
||
}
|
||
}
|
||
FREE(CxtionDn);
|
||
}
|
||
|
||
LdapSearchClose(&FrsSearchContext);
|
||
return Status;
|
||
}
|
||
|
||
DWORD
|
||
DumpConnection(
|
||
PWCHAR FromNTDSSettingsDn,
|
||
PWCHAR ToNTDSSettingsDn
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Create a new connection.
|
||
Arguments:
|
||
|
||
Return Value:
|
||
--*/
|
||
{
|
||
DWORD LStatus;
|
||
DWORD Status = ERROR_SUCCESS;
|
||
PWCHAR CxtionDn = NULL;
|
||
PWCHAR Attrs[6];
|
||
PLDAPMessage LdapMsg = NULL;
|
||
PLDAPMessage LdapEntry = NULL;
|
||
PWCHAR Val = NULL;
|
||
WCHAR SearchFilter[MAX_PATH];
|
||
FRS_LDAP_SEARCH_CONTEXT FrsSearchContext;
|
||
DWORD NoOfCxtions;
|
||
DWORD ScheduleLen;
|
||
PSCHEDULE Schedule = NULL;
|
||
BOOL SaveVerbose;
|
||
DWORD options = 0;
|
||
UINT i;
|
||
|
||
Attrs[0] = ATTR_DN;
|
||
Attrs[1] = ATTR_FROM_SERVER;
|
||
Attrs[2] = ATTR_ENABLED_CXTION;
|
||
Attrs[3] = ATTR_SCHEDULE;
|
||
Attrs[4] = ATTR_OPTIONS;
|
||
Attrs[5] = NULL;
|
||
|
||
if (bAffectAll) {
|
||
wcscpy(SearchFilter, CLASS_CXTION);
|
||
} else {
|
||
wcscpy(SearchFilter, L"(&(");
|
||
wcscat(SearchFilter, ATTR_FROM_SERVER);
|
||
wcscat(SearchFilter, L"=");
|
||
wcscat(SearchFilter, FromNTDSSettingsDn);
|
||
wcscat(SearchFilter, L")");
|
||
wcscat(SearchFilter, CLASS_CXTION);
|
||
wcscat(SearchFilter, L")");
|
||
}
|
||
|
||
if (!LdapSearchInit(pLdap,
|
||
ToNTDSSettingsDn,
|
||
LDAP_SCOPE_ONELEVEL,
|
||
SearchFilter,
|
||
Attrs,
|
||
0,
|
||
&FrsSearchContext,
|
||
FALSE)) {
|
||
return MKDSXE_CXTION_DUMP_FAILED;
|
||
}
|
||
|
||
NoOfCxtions = FrsSearchContext.EntriesInPage;
|
||
|
||
if (NoOfCxtions == 0) {
|
||
DPRINT0("Error dumping; connection not found.\n");
|
||
return MKDSXE_CXTION_NOT_FOUND_DUMP;
|
||
}
|
||
|
||
if (bAffectAll != TRUE) {
|
||
if (NoOfCxtions > 1) {
|
||
printf("Duplicate connections found. Dumping all.\n");
|
||
Status = MKDSXE_MULTIPLE_CXTIONS_DUMPED;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Scan the entries returned from ldap_search
|
||
//
|
||
for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext);
|
||
LdapEntry != NULL;
|
||
LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) {
|
||
|
||
// ATTR_DN
|
||
Val = FindValue(LdapEntry, ATTR_DN);
|
||
printf("Dn:%ws\n", Val);
|
||
FREE(Val);
|
||
|
||
// ATTR_FROM_SERVER
|
||
Val = FindValue(LdapEntry, ATTR_FROM_SERVER);
|
||
printf(" fromServer:%ws\n", Val);
|
||
FREE(Val);
|
||
|
||
// ATTR_ENABLED_CXTION
|
||
Val = FindValue(LdapEntry, ATTR_ENABLED_CXTION);
|
||
printf(" enabledCxtion:%ws\n", Val);
|
||
FREE(Val);
|
||
|
||
// ATTR_OPTIONS
|
||
Val = FindValue(LdapEntry, ATTR_OPTIONS);
|
||
if (Val) {
|
||
printf(" options:%ws [ ", Val);
|
||
options = _wtoi(Val);
|
||
for (i = 1 ; i<5;++i) {
|
||
if (NtdsConnOptions[i] & options) {
|
||
printf("%ws ", NtdsConnOptionsStr[i]);
|
||
}
|
||
}
|
||
printf("]\n");
|
||
}
|
||
FREE(Val);
|
||
|
||
// ATTR_SCHEDULE
|
||
FindBerValue(LdapEntry, ATTR_SCHEDULE, &ScheduleLen, (VOID **)&Schedule);
|
||
|
||
if (Schedule) {
|
||
SaveVerbose = bVerboseMode;
|
||
bVerboseMode = TRUE;
|
||
PrintSchedule(Schedule, 0x0F);
|
||
bVerboseMode = SaveVerbose;
|
||
delete(Schedule);
|
||
}
|
||
}
|
||
|
||
LdapSearchClose(&FrsSearchContext);
|
||
return Status;
|
||
}
|
||
|
||
VOID
|
||
PrintScheduleGrid(
|
||
PUCHAR ScheduleData,
|
||
DWORD Mask
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Print the schedule grid.
|
||
|
||
Arguments:
|
||
Schedule
|
||
Mask for each byte.
|
||
Return Value:
|
||
NONE
|
||
--*/
|
||
{
|
||
DWORD Day, Hour;
|
||
|
||
for (Day = 0; Day < 7; ++Day) {
|
||
printf(" Day %1d: ",Day + 1);
|
||
for (Hour = 0; Hour < 24; ++Hour) {
|
||
printf("%1x", *(ScheduleData + (Day * 24) + Hour) & Mask);
|
||
}
|
||
printf("\n");
|
||
}
|
||
}
|
||
|
||
|
||
VOID
|
||
PrintSchedule(
|
||
PSCHEDULE Schedule,
|
||
DWORD Mask
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Print the schedule.
|
||
|
||
Arguments:
|
||
Schedule
|
||
Mask for each byte.
|
||
Return Value:
|
||
NONE
|
||
--*/
|
||
{
|
||
PUCHAR ScheduleData;
|
||
DWORD i;
|
||
|
||
if (bVerboseMode) {
|
||
printf(" schedule:\n");
|
||
for (i = 0; i < Schedule->NumberOfSchedules; ++i) {
|
||
ScheduleData = ((PUCHAR)Schedule) + Schedule->Schedules[i].Offset;
|
||
if (Schedule->Schedules[i].Type != SCHEDULE_INTERVAL) {
|
||
continue;
|
||
}
|
||
PrintScheduleGrid(ScheduleData, Mask);
|
||
}
|
||
}
|
||
}
|
||
|
||
PWCHAR *
|
||
ConvertArgv(
|
||
DWORD argc,
|
||
PCHAR *argv
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Convert short char argv into wide char argv
|
||
|
||
Arguments:
|
||
argc - From main
|
||
argv - From main
|
||
|
||
Return Value:
|
||
Address of the new argv
|
||
--*/
|
||
{
|
||
PWCHAR *wideargv;
|
||
|
||
wideargv = new PWCHAR[argc + 1];
|
||
wideargv[argc] = NULL;
|
||
|
||
while (argc-- >= 1) {
|
||
wideargv[argc] = new WCHAR[strlen(argv[argc]) + 1];
|
||
wsprintf(wideargv[argc], L"%hs", argv[argc]);
|
||
}
|
||
return wideargv;
|
||
}
|
||
|
||
VOID
|
||
FreeArgv(
|
||
DWORD Argc,
|
||
PWCHAR *Argv
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Free the converted arguments.
|
||
|
||
Arguments:
|
||
Argc - No of arguments.
|
||
Argv - Converted arguments returned from ConvertArgv.
|
||
|
||
Return Value:
|
||
None.
|
||
--*/
|
||
{
|
||
|
||
while (Argc-- >= 1) {
|
||
FREE(Argv[Argc]);
|
||
}
|
||
FREE(Argv);
|
||
}
|
||
|
||
VOID
|
||
Usage(
|
||
PWCHAR *Argv
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
Tell the user how to use the program.
|
||
|
||
Arguments:
|
||
Argv Argument array.
|
||
|
||
Return Value:
|
||
None
|
||
--*/
|
||
{
|
||
printf("%-60s\n", "This tool creates, adds, updates, dumps, and deletes connections between DCs.\n");
|
||
printf("%-60s%ws /?\n", "Help", Argv[0]);
|
||
printf("%-60s%ws /v\n", "Verbose mode.", Argv[0]);
|
||
printf("%-60s%ws /debug\n", "Debug mode. No Writes to the DC.", Argv[0]);
|
||
printf("%-60s%ws /dc\n", "Name of the DC to connect to.", Argv[0]);
|
||
printf("%-60s%ws /name\n", "Name of the connection to be created.", Argv[0]);
|
||
printf("%-60s%ws /[create update del dump]\n", "Operation to be performed.", Argv[0]);
|
||
printf("%-60s%ws /all\n", "Perform the operation on all the connections to the", Argv[0]);
|
||
printf("%-60s%ws \n", "toserver. /all only works with /dump and /del.", Argv[0]);
|
||
printf("%-60s%ws /enable\n", "Connection is enabled.", Argv[0]);
|
||
printf("%-60s%ws /disable\n", "Connection is disabled.", Argv[0]);
|
||
printf("%-60s%ws /options <integer>\n", "Sum of the following options for connection.", Argv[0]);
|
||
printf("%-60s\n", "IsGenerated = 1");
|
||
printf("%-60s\n", "TwoWaySync = 2");
|
||
printf("%-60s\n", "OverrideNotifyDefault = 3");
|
||
printf("%-60s\n\n", "UseNotify = 4");
|
||
printf("%-60s%ws /schedule <Interval> <Stagger> <Offset>\n", "Schedule to create for the connection.", Argv[0]);
|
||
printf("%-60s%ws <Interval>\n", "The desired interval between each sync with one source.", Argv[0]);
|
||
printf("%-60s%ws <Stagger>\n", "Typically number of source DCs.", Argv[0]);
|
||
printf("%-60s%ws <Offset>\n", "Typically the number of the source DC.", Argv[0]);
|
||
printf("%-60s%ws /fromsite\n", "Name of the site the 'from' server is in.", Argv[0]);
|
||
printf("%-60s%ws /tosite\n", "Name of the site the 'to' server is in.", Argv[0]);
|
||
printf("%-60s%ws /fromserver\n", "Name of the 'from' server.", Argv[0]);
|
||
printf("%-60s%ws /toserver\n", "Name of the 'to' server.", Argv[0]);
|
||
printf("%-60s%ws /schedoverride\n", "File with 7x24 vector of schedule override data.", Argv[0]);
|
||
printf("%-60s%ws /schedmask\n", "File with 7x24 vector of schedule mask off data.", Argv[0]);
|
||
printf("%-60s\n\n", " SchedOverride and SchedMask data are formatted as 2 ascii hex digits for each schedule byte");
|
||
printf("%-60s%ws /replicasetname\n", "Name of the non-sysvol replica set.", Argv[0]);
|
||
printf("%-60s%ws /fromcomputer\n", "Name of the 'from' computer. /replicasetname needed.", Argv[0]);
|
||
printf("%-60s%ws /tocomputer\n", "Name of the 'to' computer. /replicasetname needed.", Argv[0]);
|
||
DPRINT0("\n");
|
||
DPRINT0("mkdsx.exe error return codes\n");
|
||
DPRINT0("0 = Success;\n");
|
||
DPRINT0("1 = Invalid Arguments.\n");
|
||
DPRINT0("2 = Could not bind to the DC.\n");
|
||
DPRINT0("3 = Could not find 'NTDS Settings' object for the to Server.\n");
|
||
DPRINT0("4 = Could not find 'NTDS Settings' object for the from Server.\n");
|
||
DPRINT0("5 = Error creating connection.\n");
|
||
DPRINT0("6 = Connection already exists.\n");
|
||
DPRINT0("7 = Error updating connection.\n");
|
||
DPRINT0("8 = Error updating connection; connection not found.\n");
|
||
DPRINT0("9 = Error updating connection; duplicate connections found.\n");
|
||
DPRINT0("10= Error deleting connection.\n");
|
||
DPRINT0("11= Error deleting connection; connection not found.\n");
|
||
DPRINT0("12= Deleting multiple connection.\n");
|
||
DPRINT0("13= Error dumping connection.\n");
|
||
DPRINT0("14= Error dumping; connection not found.\n");
|
||
DPRINT0("15= Dumping duplicate connections.\n");
|
||
DPRINT0("\n");
|
||
fflush(stdout);
|
||
}
|
||
|
||
DWORD __cdecl
|
||
main(
|
||
DWORD argc,
|
||
PCHAR *argv
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
|
||
Arguments:
|
||
None.
|
||
|
||
Return Value:
|
||
Exits with 0 if everything went okay. Otherwise returns a error code.
|
||
|
||
MKDSXE_SUCCESS = Success;
|
||
MKDSXE_BAD_ARG = Invalid Arguments.
|
||
MKDSXE_CANT_BIND = Could not bind to the DC.
|
||
MKDSXE_NO_T0_NTDS_SETTINGS = Could not find "NTDS Settings" object for the to Server.
|
||
MKDSXE_NO_FROM_NTDS_SETTINGS = Could not find "NTDS Settings" object for the from Server.
|
||
MKDSXE_CXTION_OBJ_CRE_FAILED = Error creating connection.
|
||
MKDSXE_CXTION_EXISTS = Connection already exists. (unused)
|
||
MKDSXE_CXTION_OBJ_UPDATE_FAILED = Error updating connection.
|
||
MKDSXE_CXTION_NOT_FOUND_UPDATE = Error updating connection; connection not found.
|
||
MKDSXE_CXTION_DUPS_FOUND_UPDATE = Error updating connection; duplicate connections found.
|
||
MKDSXE_CXTION_DELETE_FAILED = Error deleting connection.
|
||
MKDSXE_CXTION_NOT_FOUND_DELETE = Error deleting connection; connection not found.
|
||
MKDSXE_MULTIPLE_CXTIONS_DELETED = Deleting multiple connection.
|
||
MKDSXE_CXTION_DUMP_FAILED = Error dumping connection.
|
||
MKDSXE_CXTION_NOT_FOUND_DUMP = Error dumping; connection not found.
|
||
MKDSXE_MULTIPLE_CXTIONS_DUMPED = Dumping duplicate connections.
|
||
|
||
--*/
|
||
{
|
||
PWCHAR *Argv;
|
||
ULONG i, j;
|
||
ULONG OptLen;
|
||
DWORD Status = ERROR_SUCCESS;
|
||
PWCHAR FromSite = NULL;
|
||
PWCHAR FromServer = NULL;
|
||
PWCHAR ToSite = NULL;
|
||
PWCHAR ToServer = NULL;
|
||
PWCHAR ReplicaSetName = NULL;
|
||
PWCHAR FromComputer = NULL;
|
||
PWCHAR ToComputer = NULL;
|
||
PWCHAR ToNTDSSettingsDn = NULL; // These parameters are settingsDn in sysvol replica sets
|
||
PWCHAR FromNTDSSettingsDn = NULL; // and memberDn in non sysvol replica sets.
|
||
PWCHAR CxtionName = NULL;
|
||
PBYTE pSchedule = NULL;
|
||
DWORD Interval = 1;
|
||
DWORD Stagger = 1;
|
||
DWORD Offset = 0;
|
||
DWORD Options = 0xffffffff;
|
||
BOOL bEnabled = TRUE;
|
||
BOOL bCreateConnection = FALSE;
|
||
BOOL bUpdateConnection = FALSE;
|
||
BOOL bDelConnection = FALSE;
|
||
BOOL bDumpConnection = FALSE;
|
||
BOOL bSchedule = FALSE;
|
||
|
||
Argv = ConvertArgv(argc, argv);
|
||
|
||
if (argc <= 1) {
|
||
Usage(Argv);
|
||
FreeArgv(argc,Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
|
||
for (i = 1; i < argc; ++i) {
|
||
OptLen = wcslen(Argv[i]);
|
||
if (OptLen == 2 &&
|
||
((wcsstr(Argv[i], L"/v") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-v") == Argv[i]))) {
|
||
bVerboseMode=TRUE;
|
||
|
||
} else if (OptLen == 2 &&
|
||
((wcsstr(Argv[i], L"/?") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-?") == Argv[i]))) {
|
||
Usage(Argv);
|
||
FreeArgv(argc,Argv);
|
||
return MKDSXE_SUCCESS;
|
||
|
||
} else if (OptLen == 6 &&
|
||
((wcsstr(Argv[i], L"/debug") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-debug") == Argv[i]))) {
|
||
bDebugMode = TRUE;
|
||
bVerboseMode=TRUE;
|
||
|
||
} else if (OptLen == 3 && (i+1 < argc) &&
|
||
((wcsstr(Argv[i], L"/dc") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-dc") == Argv[i]))) {
|
||
i+=1;
|
||
DcName = new WCHAR[wcslen(Argv[i])+1];
|
||
wcscpy(DcName, Argv[i]);
|
||
|
||
} else if (OptLen == 9 && (i+1 < argc) &&
|
||
((wcsstr(Argv[i], L"/fromsite") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-fromsite") == Argv[i]))) {
|
||
i+=1;
|
||
FromSite = new WCHAR[wcslen(Argv[i])+1];
|
||
wcscpy(FromSite, Argv[i]);
|
||
|
||
} else if (OptLen == 11 && (i+1 < argc) &&
|
||
((wcsstr(Argv[i], L"/fromserver") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-fromserver") == Argv[i]))) {
|
||
i+=1;
|
||
FromServer = new WCHAR[wcslen(Argv[i])+1];
|
||
wcscpy(FromServer, Argv[i]);
|
||
|
||
} else if (OptLen == 7 && (i+1 < argc) &&
|
||
((wcsstr(Argv[i], L"/tosite") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-tosite") == Argv[i]))) {
|
||
i+=1;
|
||
ToSite = new WCHAR[wcslen(Argv[i])+1];
|
||
wcscpy(ToSite, Argv[i]);
|
||
|
||
} else if (OptLen == 9 && (i+1 < argc) &&
|
||
((wcsstr(Argv[i], L"/toserver") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-toserver") == Argv[i]))) {
|
||
i+=1;
|
||
ToServer = new WCHAR[wcslen(Argv[i])+1];
|
||
wcscpy(ToServer, Argv[i]);
|
||
} else if (OptLen == 15 &&
|
||
((wcsstr(Argv[i], L"/replicasetname") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-replicasetname") == Argv[i]))) {
|
||
if( ++i >= argc ){
|
||
Usage(Argv);
|
||
FreeArgv(argc,Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
ReplicaSetName = new WCHAR[wcslen(Argv[i])+1];
|
||
wcscpy(ReplicaSetName, Argv[i]);
|
||
} else if (OptLen == 13 &&
|
||
((wcsstr(Argv[i], L"/fromcomputer") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-fromcomputer") == Argv[i]))) {
|
||
if( ++i >= argc ){
|
||
Usage(Argv);
|
||
FreeArgv(argc,Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
FromComputer = new WCHAR[wcslen(Argv[i])+1];
|
||
wcscpy(FromComputer, Argv[i]);
|
||
} else if (OptLen == 11 &&
|
||
((wcsstr(Argv[i], L"/tocomputer") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-tocomputer") == Argv[i]))) {
|
||
if( ++i >= argc ){
|
||
Usage(Argv);
|
||
FreeArgv(argc,Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
ToComputer = new WCHAR[wcslen(Argv[i])+1];
|
||
wcscpy(ToComputer, Argv[i]);
|
||
} else if (OptLen == 5 &&
|
||
((wcsstr(Argv[i], L"/name") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-name") == Argv[i]))) {
|
||
i+=1;
|
||
CxtionName = new WCHAR[wcslen(Argv[i])+1];
|
||
wcscpy(CxtionName, Argv[i]);
|
||
|
||
} else if (OptLen == 9 && (i+3 < argc) &&
|
||
((wcsstr(Argv[i], L"/schedule") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-schedule") == Argv[i]))) {
|
||
|
||
bSchedule = TRUE;
|
||
Interval = _wtoi(Argv[i+1]);
|
||
Stagger = _wtoi(Argv[i+2]);
|
||
Offset = _wtoi(Argv[i+3]);
|
||
i+=3;
|
||
|
||
} else if ((OptLen == 10) && (i+1 < argc) &&
|
||
((wcsstr(Argv[i], L"/schedmask") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-schedmask") == Argv[i]))) {
|
||
|
||
SchedMask = ReadScheduleFile(Argv[i+1]);
|
||
if (SchedMask == NULL) {
|
||
FreeArgv(argc,Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
} else {
|
||
if (bVerboseMode) {
|
||
printf(" schedmask:\n");
|
||
PrintScheduleGrid(SchedMask, 0x0F);
|
||
}
|
||
}
|
||
i+=1;
|
||
|
||
} else if ((OptLen == 14) && (i+1 < argc) &&
|
||
((wcsstr(Argv[i], L"/schedoverride") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-schedoverride") == Argv[i]))) {
|
||
|
||
SchedOverride = ReadScheduleFile(Argv[i+1]);
|
||
if (SchedOverride == NULL) {
|
||
FreeArgv(argc,Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
} else {
|
||
if (bVerboseMode) {
|
||
printf(" schedoverride:\n");
|
||
PrintScheduleGrid(SchedOverride, 0x0F);
|
||
}
|
||
}
|
||
i+=1;
|
||
|
||
} else if (OptLen == 8 && (i+1 < argc) &&
|
||
((wcsstr(Argv[i], L"/options") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-options") == Argv[i]))) {
|
||
i+=1;
|
||
Options = _wtoi(Argv[i]);
|
||
if (Options > NtdsConnOptionsMax) {
|
||
Usage(Argv);
|
||
FreeArgv(argc,Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
|
||
} else if (OptLen == 7 &&
|
||
((wcsstr(Argv[i], L"/enable") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-enable") == Argv[i]))) {
|
||
bEnabled = TRUE;
|
||
|
||
} else if (OptLen == 8 &&
|
||
((wcsstr(Argv[i], L"/disable") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-disable") == Argv[i]))) {
|
||
bEnabled = FALSE;
|
||
|
||
} else if (OptLen == 7 &&
|
||
((wcsstr(Argv[i], L"/create") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-create") == Argv[i]))) {
|
||
bCreateConnection = TRUE;
|
||
|
||
} else if (OptLen == 7 &&
|
||
((wcsstr(Argv[i], L"/update") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-update") == Argv[i]))) {
|
||
bUpdateConnection = TRUE;
|
||
|
||
} else if (OptLen == 4 &&
|
||
((wcsstr(Argv[i], L"/del") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-del") == Argv[i]))) {
|
||
bDelConnection = TRUE;
|
||
|
||
} else if (OptLen == 5 &&
|
||
((wcsstr(Argv[i], L"/dump") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-dump") == Argv[i]))) {
|
||
bDumpConnection = TRUE;
|
||
|
||
} else if (OptLen == 4 &&
|
||
((wcsstr(Argv[i], L"/all") == Argv[i]) ||
|
||
(wcsstr(Argv[i], L"-all") == Argv[i]))) {
|
||
bAffectAll = TRUE;
|
||
|
||
} else {
|
||
Usage(Argv);
|
||
FreeArgv(argc,Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
}
|
||
|
||
FreeArgv(argc,Argv);
|
||
|
||
if (ReplicaSetName != NULL) {
|
||
if (bAffectAll == TRUE) {
|
||
if (DcName == NULL ||
|
||
ToComputer == NULL) {
|
||
Usage(Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
} else if (DcName == NULL || FromComputer == NULL ||
|
||
ToComputer == NULL) {
|
||
Usage(Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
|
||
} else {
|
||
if (bAffectAll == TRUE) {
|
||
if (DcName == NULL ||
|
||
ToSite == NULL || ToServer == NULL ) {
|
||
Usage(Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
} else if (DcName == NULL || FromSite == NULL || FromServer == NULL ||
|
||
ToSite == NULL || ToServer == NULL ) {
|
||
Usage(Argv);
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
|
||
}
|
||
Status = BindToDC(DcName, &pLdap);
|
||
if (Status != ERROR_SUCCESS) {
|
||
return MKDSXE_CANT_BIND;
|
||
}
|
||
|
||
if (ReplicaSetName != NULL) {
|
||
Status = FormMemberDn(ReplicaSetName, ToComputer, &ToNTDSSettingsDn);
|
||
} else {
|
||
Status = FormNTDSSettingsDn(ToSite, ToServer, &ToNTDSSettingsDn);
|
||
}
|
||
|
||
if (Status != ERROR_SUCCESS) {
|
||
return MKDSXE_NO_T0_NTDS_SETTINGS;
|
||
}
|
||
|
||
//
|
||
// We need the from server only if Affectall is not set.
|
||
//
|
||
if (bAffectAll != TRUE) {
|
||
if (ReplicaSetName != NULL) {
|
||
Status = FormMemberDn(ReplicaSetName, FromComputer, &FromNTDSSettingsDn);
|
||
} else {
|
||
Status = FormNTDSSettingsDn(FromSite, FromServer, &FromNTDSSettingsDn);
|
||
}
|
||
|
||
if (Status != ERROR_SUCCESS) {
|
||
return MKDSXE_NO_FROM_NTDS_SETTINGS;
|
||
}
|
||
}
|
||
|
||
//
|
||
// /all does not make sense with create.
|
||
//
|
||
if ((bAffectAll) && (bCreateConnection || bUpdateConnection) ) {
|
||
Usage(Argv);
|
||
DPRINT0("Error - /all can not be used with /create or /update.\n");
|
||
return MKDSXE_BAD_ARG;
|
||
}
|
||
|
||
if (bCreateConnection) {
|
||
if (CxtionName == NULL) {
|
||
DPRINT0("Need a cxtion name to create a new connection\n");
|
||
Status = MKDSXE_BAD_ARG;
|
||
} else {
|
||
if (bSchedule) {
|
||
BuildSchedule(&pSchedule, Interval, Stagger, Offset);
|
||
Status = CreateNewConnection(CxtionName, FromNTDSSettingsDn, ToNTDSSettingsDn, bEnabled, Options, pSchedule);
|
||
} else {
|
||
Status = CreateNewConnection(CxtionName, FromNTDSSettingsDn, ToNTDSSettingsDn, bEnabled, Options, NULL);
|
||
}
|
||
}
|
||
} else if (bUpdateConnection) {
|
||
if (bSchedule) {
|
||
BuildSchedule(&pSchedule, Interval, Stagger, Offset);
|
||
Status = UpdateConnection(FromNTDSSettingsDn, ToNTDSSettingsDn, bEnabled, Options, pSchedule);
|
||
} else {
|
||
Status = UpdateConnection(FromNTDSSettingsDn, ToNTDSSettingsDn, bEnabled, Options, NULL);
|
||
}
|
||
} else if (bDelConnection) {
|
||
Status = DelConnection(FromNTDSSettingsDn, ToNTDSSettingsDn);
|
||
} else if (bDumpConnection) {
|
||
Status = DumpConnection(FromNTDSSettingsDn, ToNTDSSettingsDn);
|
||
}
|
||
|
||
ldap_unbind(pLdap);
|
||
return Status;
|
||
}
|
||
|