#include #include #include #include #include #include #include #include #include #include #define ArgMatch(_a, _b) (wcsstr(_a, _b) == (_a)) #define WCS_CAT7(_dest, _a1, _a2, _a3, _a4, _a5, _a6, _a7 ) \ wcscpy(_dest, _a1); \ wcscat(_dest, _a2); \ wcscat(_dest, _a3); \ wcscat(_dest, _a4); \ wcscat(_dest, _a5); \ wcscat(_dest, _a6); \ wcscat(_dest, _a7); // // Some useful ldap macroes // #define LDAP_FREE_MSG(x) {if (x) {ldap_msgfree(x); (x) = NULL;}} #define LDAP_FREE_VALUES(x) {if (x) {ldap_value_free(x); (x) = NULL;}} #define LDAP_FREE_BER_VALUES(x) {if (x) {ldap_value_free_len(x); (x) = NULL;}} //Global data BOOL bVerboseMode = FALSE; BOOL bVerboseModeSearch = FALSE; PWCHAR DcName = NULL; PLDAP pLdap = NULL; BOOL bDebugMode = FALSE; BOOL bAffectAll = FALSE; PBYTE SchedMask = NULL; PBYTE SchedOverride = NULL; BOOL bCreateSet = FALSE; BOOL bUpdateSet = FALSE; BOOL bDelSet = FALSE; BOOL bCreateMember = FALSE; BOOL bMakeMePrimary = FALSE; BOOL bUpdateMember = FALSE; BOOL bDelMember = FALSE; BOOL bCreateSubscriber = FALSE; BOOL bUpdateSubscriber = FALSE; BOOL bDelSubscriber = FALSE; BOOL bDump = FALSE; BOOL bSchedule = FALSE; BOOL bDFSNaming = FALSE; WCHAR ComputerObjectGuidStr[50]; PWCHAR DomainGuidStr = NULL; // [50]; PWCHAR DFSName = NULL; // // Static array to print the replica set type. // WCHAR ReplicaSetTypeStr[][MAX_PATH] = {L"Invalid type", L"Invalid type", L"Sysvol", L"Dfs", L"Other"}; DWORD UpdateReplicaSet( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName, PWCHAR ReplicaSetType, PWCHAR FileFilter, PWCHAR DirectoryFilter, PWCHAR PrimaryMember, PBYTE pSchedule ); 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_FREE_VALUES(). --*/ { 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_FREE_VALUES(). 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 // MK_ATTRS_1(Attrs, DesiredAttr); // // 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_FREE_MSG(LdapMsg); return Values; } PLDAP_BERVAL * GetBerValues( IN PLDAP Ldap, IN PWCHAR Dn, IN PWCHAR DesiredAttr, IN BOOL Quiet ) /*++ Routine Description: Return the DS Ber values for one binary 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 BerVal struct pointers that represents the values for the attribute. The caller must free the array with LDAP_FREE_BER_VALUES(). NULL if unsuccessful. --*/ { PWCHAR Attr; BerElement *Ber; PLDAPMessage LdapMsg; PLDAPMessage LdapEntry; PWCHAR Attrs[2]; PLDAP_BERVAL *Values = NULL; // // Search Base for all of its attributes + values // MK_ATTRS_1(Attrs, DesiredAttr); // // 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_len(Ldap, LdapEntry, Attr); } } LDAP_FREE_MSG(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_FREE_VALUES(). --*/ { 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_FREE_VALUES(). --*/ { 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_FREE_VALUES(). --*/ { 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_FREE_MSG(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_FREE_VALUES(). --*/ { 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_FREE_VALUES(). --*/ { FrsSearchContext->bOpen = FALSE; FrsSearchContext->EntriesInPage = 0; FrsSearchContext->CurrentEntry = 0; FrsSearchContext->TotalEntries = 0; FREE(FrsSearchContext->Filter); FREE(FrsSearchContext->BaseDn); if (FrsSearchContext->LdapMsg != NULL) { LDAP_FREE_MSG(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_FREE_VALUES(Values); return Root; } } DPRINT1("ERROR - COULD NOT FIND %ws\n", NamingContext); LDAP_FREE_VALUES(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_FREE_VALUES(). 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_FREE_VALUES(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_FREE_BER_VALUES(Values); return TRUE; } 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; iSize = 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 1) { printf("Error deleting Subscription; duplicate members found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_DUPS_FOUND_DELETE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { MemberDn = FindValue(LdapEntry, ATTR_DN); } LdapSearchClose(&FrsSearchContext); } DPRINT1("MemberDn:%ws\n", MemberDn); if (ComputerDn == NULL) { // // Use MemberDn to find the computerDn. We will come here // only if MemberName is supplied but computerdn is not. // if (!LdapSearchInit(pLdap, MemberDn, LDAP_SCOPE_BASE, NULL, MemberAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIPTION_DELETE_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if (NoOfMembers == 0) { printf("Error deleting Subscription; member not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_NOT_FOUND_DELETE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { LocalComputerDn = FindValue(LdapEntry, ATTR_COMPUTER_REF); if (LocalComputerDn == NULL) { printf("Error deleting Subscription; computerdn not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_NOT_FOUND_DELETE; goto CLEANUP; } } LdapSearchClose(&FrsSearchContext); } else { LocalComputerDn = FrsWcsDup(ComputerDn); } // // We have the computerdn and the memberdn. Now check if a Subscription // already exists. // WCS_CAT7(SearchFilter, L"(&(", ATTR_MEMBER_REF, L"=", MemberDn, L")" , CLASS_SUBSCRIPTION, L")"); if (!LdapSearchInit(pLdap, LocalComputerDn, LDAP_SCOPE_SUBTREE, SearchFilter, SubscriptionAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIPTION_DELETE_FAILED; goto CLEANUP; } NoOfSubscriptions = FrsSearchContext.EntriesInPage; if ((NoOfSubscriptions > 1) && (bAffectAll != TRUE)) { printf("Duplicate Subscriptions found. Deleting all.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_DUPS_FOUND_DELETE; goto CLEANUP; } if (NoOfSubscriptions != 0) { // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { SubscriptionDn = FindValue(LdapEntry, ATTR_DN); DPRINT1("Deleting Dn:%ws\n", SubscriptionDn); if (bDebugMode) { DPRINT1("LStatus = ldap_delete_s(pLdap, %ws);\n", SubscriptionDn); } else { LStatus = ldap_delete_s(pLdap, SubscriptionDn); if (LStatus != LDAP_SUCCESS) { printf("ERROR - Can't delete %ws: %ws\n", SubscriptionDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIPTION_DELETE_FAILED; } } FREE(SubscriptionDn); } } else { printf("Warning deleting; Subscription not found.\n"); Status = MKDSOE_SUBSCRIPTION_NOT_FOUND_DELETE; } LdapSearchClose(&FrsSearchContext); CLEANUP: FREE(SearchFilter); FREE(ReplicaSetDn); FREE(MemberDn); FREE(LocalComputerDn); FREE(SubscriptionDn); FreeMod(&Mod); return Status; } DWORD UpdateSubscription( PWCHAR SubscriptionDn, PWCHAR MemberRef, PWCHAR RootPath, PWCHAR StagePath ) /*++ Routine Description: Update the Subscription. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR Attrs[5]; PLDAPMessage LdapEntry = NULL; PWCHAR CurMemberRef = NULL; PWCHAR CurRootPath = NULL; PWCHAR CurStagePath = NULL; DWORD NoOfSubscriptions; BOOL bNeedsUpdate = FALSE; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; MK_ATTRS_4(Attrs, ATTR_DN, ATTR_MEMBER_REF, ATTR_REPLICA_ROOT, ATTR_REPLICA_STAGE); if (!LdapSearchInit(pLdap, SubscriptionDn, LDAP_SCOPE_BASE, NULL, Attrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIPTION_OBJ_UPDATE_FAILED; goto CLEANUP; } NoOfSubscriptions = FrsSearchContext.EntriesInPage; if (NoOfSubscriptions == 0) { printf("Error updating; Subscription not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_NOT_FOUND_UPDATE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { CurMemberRef = FindValue(LdapEntry, ATTR_MEMBER_REF); CurRootPath = FindValue(LdapEntry, ATTR_REPLICA_ROOT); CurStagePath = FindValue(LdapEntry, ATTR_REPLICA_STAGE); } LdapSearchClose(&FrsSearchContext); DPRINT1("SubscriptionDn:%ws\n", SubscriptionDn); // Check ATTR_MEMBER_REF // if a ref is supplied then make sure it is same as the current ref. // if a ref is not supplied then leave it as it is. if (MemberRef != NULL) { if ((CurMemberRef == NULL) || ((CurMemberRef != NULL) && wcscmp(MemberRef, CurMemberRef))) { AddMod(ATTR_MEMBER_REF, MemberRef, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsMemberReference:%ws\n", MemberRef); } } // Check ATTR_REPLICA_ROOT // if a path is supplied then make sure it is same as the current path. // if a path is not supplied then leave it as it is. if (RootPath != NULL) { if ((CurRootPath == NULL) || ((CurRootPath != NULL) && wcscmp(RootPath, CurRootPath))) { AddMod(ATTR_REPLICA_ROOT, RootPath, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsRootPath:%ws\n", RootPath); } } // Check ATTR_REPLICA_STAGE // if a path is supplied then make sure it is same as the current path. // if a path is not supplied then leave it as it is. if (StagePath != NULL) { if ((CurStagePath == NULL) || ((CurStagePath != NULL) && wcscmp(StagePath, CurStagePath))) { AddMod(ATTR_REPLICA_STAGE, StagePath, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsRootPath:%ws\n", StagePath); } } if (bNeedsUpdate) { if (bDebugMode) { DPRINT1("LStatus = ldap_modify_s(pLdap, %ws, Mod);\n", SubscriptionDn); } else { LStatus = ldap_modify_s(pLdap, SubscriptionDn, Mod); if (LStatus != LDAP_SUCCESS) { printf("ERROR - Can't update %ws: %ws\n", SubscriptionDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIPTION_OBJ_UPDATE_FAILED; } } } else { printf("No update required\n"); } CLEANUP: FREE(CurMemberRef); FREE(CurRootPath); FREE(CurStagePath); FreeMod(&Mod); return Status; } DWORD CreateNewSubscription( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName, PWCHAR MemberName, PWCHAR ComputerDn, PWCHAR RootPath, PWCHAR StagePath, PWCHAR RefDCName ) /*++ Routine Description: Create a new Subscription. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR ReplicaSetDn = NULL; PWCHAR MemberDn = NULL; PWCHAR SubscriptionDn = NULL; PWCHAR MemberAttrs[3]; PWCHAR SubscriptionAttrs[3]; PWCHAR SearchFilter = NULL; DWORD NoOfMembers; DWORD NoOfSubscriptions; PWCHAR LocalComputerDn = NULL; PLDAPMessage LdapEntry = NULL; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; MK_ATTRS_2(MemberAttrs, ATTR_DN, ATTR_COMPUTER_REF); MK_ATTRS_2(SubscriptionAttrs, ************* ATTR_DN, ATTR_MEMBER_REF); // // We need to get to the member object and the computer object. // To get to the member object we need the member name or the computer dn. // // To get to the computer object we need a member with valid computerref // or the computerdn parameter. // if ((MemberName == NULL) && (ComputerDn == NULL)) { Status = MKDSOE_BAD_ARG; return Status; } SearchFilter = (PWCHAR) malloc((max((ComputerDn != NULL)?wcslen(ComputerDn):0, (MemberDn != NULL)?wcslen(MemberDn):0) + MAX_PATH) * sizeof(WCHAR)); ReplicaSetDn = ExtendDn(NTFRSSettingsDn, ReplicaSetName); if (MemberName != NULL) { MemberDn = ExtendDn(ReplicaSetDn, MemberName); } else { // // Use computerdn to get the memberdn. // WCS_CAT7(SearchFilter, L"(&(", ATTR_COMPUTER_REF, L"=", ComputerDn, L")" , CLASS_MEMBER, L")"); if (!LdapSearchInit(pLdap, ReplicaSetDn, LDAP_SCOPE_ONELEVEL, SearchFilter, MemberAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if (NoOfMembers == 0) { printf("Error creating Subscription; member not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } if (NoOfMembers > 1) { printf("Error creating Subscription; duplicate members found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_DUPS_FOUND_UPDATE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { MemberDn = FindValue(LdapEntry, ATTR_DN); } LdapSearchClose(&FrsSearchContext); } DPRINT1("MemberDn:%ws\n", MemberDn); if (ComputerDn == NULL) { // // Use MemberDn to find the computerDn. We will come here // only if MemberName is supplied but computerdn is not. // if (!LdapSearchInit(pLdap, MemberDn, LDAP_SCOPE_BASE, NULL, MemberAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if (NoOfMembers == 0) { printf("Error creating Subscription; member not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { LocalComputerDn = FindValue(LdapEntry, ATTR_COMPUTER_REF); if (LocalComputerDn == NULL) { printf("Error creating Subscription; computerdn not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } } LdapSearchClose(&FrsSearchContext); } else { LocalComputerDn = FrsWcsDup(ComputerDn); } // // We have the computerdn and the memberdn. Now check if a Subscription // already exists. // WCS_CAT7(SearchFilter, L"(&(", ATTR_MEMBER_REF, L"=", MemberDn, L")" , CLASS_SUBSCRIPTION, L")"); if (!LdapSearchInit(pLdap, LocalComputerDn, LDAP_SCOPE_SUBTREE, SearchFilter, SubscriptionAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } NoOfSubscriptions = FrsSearchContext.EntriesInPage; if (NoOfSubscriptions > 1) { printf("Error creating Subscription; duplicate found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIPTION_DUPS_FOUND_UPDATE; goto CLEANUP; } if (NoOfSubscriptions == 1) { // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { SubscriptionDn = FindValue(LdapEntry, ATTR_DN); } Status = UpdateSubscription(SubscriptionDn, MemberDn, RootPath, StagePath); } else { SubscriptionDn = ExtendDn(LocalComputerDn, MKDSOE_SUBSCRIPTION); // ATTR_DN DPRINT1("SubscriptionDn:%ws\n", SubscriptionDn); AddMod(ATTR_CLASS, ATTR_SUBSCRIPTIONS, &Mod); if (bDebugMode) { DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", SubscriptionDn); } else { LStatus = ldap_add_s(pLdap, SubscriptionDn, Mod); if ((LStatus != LDAP_ALREADY_EXISTS) && (LStatus != LDAP_SUCCESS)) { printf("ERROR - Can't create %ws: %ws\n", SubscriptionDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } } FreeMod(&Mod); ************ check SubscriptionDn = ExtendDn(SubscriptionDn, ReplicaSetName); // ATTR_DN DPRINT1("SubscriptionDn:%ws\n", SubscriptionDn); AddMod(ATTR_CLASS, ATTR_SUBSCRIPTION, &Mod); // ATTR_MEMBER_REF AddMod(ATTR_MEMBER_REF, MemberDn, &Mod); DPRINT1(" FrsMemberReference:%ws\n", MemberDn); // ATTR_REPLICA_ROOT AddMod(ATTR_REPLICA_ROOT, RootPath, &Mod); DPRINT1(" FrsRootPath:%ws\n", RootPath); // ATTR_REPLICA_STAGE AddMod(ATTR_REPLICA_STAGE, StagePath, &Mod); DPRINT1(" FrsStagePath:%ws\n", StagePath); if (bDebugMode) { DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", SubscriptionDn); } else { LStatus = ldap_add_s(pLdap, SubscriptionDn, Mod); if ((LStatus == LDAP_CONSTRAINT_VIOLATION) && RefDCName != NULL) { // // prepare the server hint. Needed in case the member object // is just created on another DC than the one on which the // Subscription is being created. // LDAPControl simpleControl; PLDAPControl controlArray[2]; INT rc; BERVAL* pBerVal = NULL; BerElement* pBer; pBer = ber_alloc_t(LBER_USE_DER); if (!pBer) { Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } DPRINT1("Sending binding DC Name %ws\n",RefDCName); rc = ber_printf(pBer,"{io}", 0, RefDCName, wcslen(RefDCName) * sizeof(WCHAR)); if ( rc == -1 ) { Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } rc = ber_flatten(pBer, &pBerVal); if (rc == -1) { Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; goto CLEANUP; } ber_free(pBer,1); controlArray[0] = &simpleControl; controlArray[1] = NULL; // simpleControl.ldctl_oid = LDAP_SERVER_GC_VERIFY_NAME_OID_W; simpleControl.ldctl_oid = LDAP_SERVER_VERIFY_NAME_OID_W; simpleControl.ldctl_iscritical = TRUE; simpleControl.ldctl_value = *pBerVal; LStatus = ldap_add_ext_s(pLdap, SubscriptionDn, Mod, (PLDAPControl *)&controlArray, //ServerControls, NULL //ClientControls, ); } 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 objects that have changed. // Status = UpdateSubscription(SubscriptionDn, MemberDn, RootPath, StagePath); } else if (LStatus != LDAP_SUCCESS) { DPRINT2("ERROR - Can't create %ws: %ws\n", SubscriptionDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIPTION_OBJ_CRE_FAILED; } } } LdapSearchClose(&FrsSearchContext); CLEANUP: FreeMod(&Mod); FREE(ReplicaSetDn); FREE(MemberDn); FREE(SubscriptionDn); FREE(SearchFilter); FREE(LocalComputerDn); return Status; } #endif 0 DWORD DeleteSubscriber( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName, PWCHAR MemberName, PWCHAR ComputerDn ) /*++ Routine Description: Delete a subscriber. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR ReplicaSetDn = NULL; PWCHAR MemberDn = NULL; PWCHAR SubscriberDn = NULL; PWCHAR MemberAttrs[3]; PWCHAR SubscriberAttrs[3]; PWCHAR SearchFilter = NULL; DWORD NoOfMembers; DWORD NoOfSubscribers; PWCHAR LocalComputerDn = NULL; PLDAPMessage LdapEntry = NULL; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; MK_ATTRS_2(MemberAttrs, ATTR_DN, ATTR_COMPUTER_REF); MK_ATTRS_2(SubscriberAttrs, ATTR_DN, ATTR_MEMBER_REF); // // We need to get to the member object and the computer object. // To get to the member object we need the member name or the computer dn. // To get to the computer object we need a member with valid computerref // or the computerdn parameter. // if ((MemberName == NULL) && (ComputerDn == NULL)) { printf("ERROR: MemberName and ComputerDn are NULL in DeleteSubscriber.\n"); Status = MKDSOE_BAD_ARG; return Status; } SearchFilter = (PWCHAR) malloc((max((ComputerDn != NULL)?wcslen(ComputerDn):0, (MemberDn != NULL)?wcslen(MemberDn):0) + MAX_PATH) * sizeof(WCHAR)); ReplicaSetDn = ExtendDn(NTFRSSettingsDn, ReplicaSetName); if (MemberName != NULL) { MemberDn = ExtendDn(ReplicaSetDn, MemberName); } else { // // Use computerdn to get the memberdn. // WCS_CAT7(SearchFilter, L"(&(", ATTR_COMPUTER_REF, L"=", ComputerDn, L")" , CLASS_MEMBER, L")"); if (!LdapSearchInit(pLdap, ReplicaSetDn, LDAP_SCOPE_ONELEVEL, SearchFilter, MemberAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIBER_DELETE_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if (NoOfMembers == 0) { printf("Error deleting subscriber; member not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_NOT_FOUND_DELETE; goto CLEANUP; } if (NoOfMembers > 1) { printf("Error deleting subscriber; duplicate members found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_DUPS_FOUND_DELETE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { MemberDn = FindValue(LdapEntry, ATTR_DN); } LdapSearchClose(&FrsSearchContext); } DPRINT1("MemberDn:%ws\n", MemberDn); if (ComputerDn == NULL) { // // Use MemberDn to find the computerDn. We will come here // only if MemberName is supplied but computerdn is not. // if (!LdapSearchInit(pLdap, MemberDn, LDAP_SCOPE_BASE, NULL, MemberAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIBER_DELETE_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if (NoOfMembers == 0) { printf("Error deleting subscriber; member not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_NOT_FOUND_DELETE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { LocalComputerDn = FindValue(LdapEntry, ATTR_COMPUTER_REF); if (LocalComputerDn == NULL) { printf("Error deleting subscriber; computerdn not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_NOT_FOUND_DELETE; goto CLEANUP; } } LdapSearchClose(&FrsSearchContext); } else { LocalComputerDn = FrsWcsDup(ComputerDn); } // // We have the computerdn and the memberdn. Now check if a subscriber // already exists. // WCS_CAT7(SearchFilter, L"(&(", ATTR_MEMBER_REF, L"=", MemberDn, L")" , CLASS_SUBSCRIBER, L")"); if (!LdapSearchInit(pLdap, LocalComputerDn, LDAP_SCOPE_SUBTREE, SearchFilter, SubscriberAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIBER_DELETE_FAILED; goto CLEANUP; } NoOfSubscribers = FrsSearchContext.EntriesInPage; if ((NoOfSubscribers > 1) && (bAffectAll != TRUE)) { printf("Duplicate subscribers found. Deleting all.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_DUPS_FOUND_DELETE; goto CLEANUP; } if (NoOfSubscribers != 0) { // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { SubscriberDn = FindValue(LdapEntry, ATTR_DN); DPRINT1("Deleting Dn:%ws\n", SubscriberDn); if (bDebugMode) { DPRINT1("LStatus = ldap_delete_s(pLdap, %ws);\n", SubscriberDn); } else { LStatus = ldap_delete_s(pLdap, SubscriberDn); if (LStatus != LDAP_SUCCESS) { printf("ERROR - Can't delete %ws: %ws\n", SubscriberDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIBER_DELETE_FAILED; } } FREE(SubscriberDn); } } else { printf("Warning deleting; subscriber not found.\n"); Status = MKDSOE_SUBSCRIBER_NOT_FOUND_DELETE; } LdapSearchClose(&FrsSearchContext); CLEANUP: FREE(SearchFilter); FREE(ReplicaSetDn); FREE(MemberDn); FREE(LocalComputerDn); FREE(SubscriberDn); FreeMod(&Mod); return Status; } DWORD UpdateSubscriber( PWCHAR SubscriberDn, PWCHAR MemberRef, PWCHAR RootPath, PWCHAR StagePath ) /*++ Routine Description: Update the subscriber. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR Attrs[5]; PLDAPMessage LdapEntry = NULL; PWCHAR CurMemberRef = NULL; PWCHAR CurRootPath = NULL; PWCHAR CurStagePath = NULL; DWORD NoOfSubscribers; BOOL bNeedsUpdate = FALSE; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; MK_ATTRS_4(Attrs, ATTR_DN, ATTR_MEMBER_REF, ATTR_REPLICA_ROOT, ATTR_REPLICA_STAGE); if (!LdapSearchInit(pLdap, SubscriberDn, LDAP_SCOPE_BASE, NULL, Attrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIBER_OBJ_UPDATE_FAILED; goto CLEANUP; } NoOfSubscribers = FrsSearchContext.EntriesInPage; if (NoOfSubscribers == 0) { printf("Error updating; subscriber not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_NOT_FOUND_UPDATE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { CurMemberRef = FindValue(LdapEntry, ATTR_MEMBER_REF); CurRootPath = FindValue(LdapEntry, ATTR_REPLICA_ROOT); CurStagePath = FindValue(LdapEntry, ATTR_REPLICA_STAGE); } LdapSearchClose(&FrsSearchContext); DPRINT1("SubscriberDn:%ws\n", SubscriberDn); // Check ATTR_MEMBER_REF // if a ref is supplied then make sure it is same as the current ref. // if a ref is not supplied then leave it as it is. if (MemberRef != NULL) { if ((CurMemberRef == NULL) || ((CurMemberRef != NULL) && wcscmp(MemberRef, CurMemberRef))) { AddMod(ATTR_MEMBER_REF, MemberRef, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsMemberReference:%ws\n", MemberRef); } } // Check ATTR_REPLICA_ROOT // if a path is supplied then make sure it is same as the current path. // if a path is not supplied then leave it as it is. if (RootPath != NULL) { if ((CurRootPath == NULL) || ((CurRootPath != NULL) && wcscmp(RootPath, CurRootPath))) { AddMod(ATTR_REPLICA_ROOT, RootPath, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsRootPath:%ws\n", RootPath); } } // Check ATTR_REPLICA_STAGE // if a path is supplied then make sure it is same as the current path. // if a path is not supplied then leave it as it is. if (StagePath != NULL) { if ((CurStagePath == NULL) || ((CurStagePath != NULL) && wcscmp(StagePath, CurStagePath))) { AddMod(ATTR_REPLICA_STAGE, StagePath, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsStagePath:%ws\n", StagePath); } } if (bNeedsUpdate) { if (bDebugMode) { DPRINT1("LStatus = ldap_modify_s(pLdap, %ws, Mod);\n", SubscriberDn); } else { LStatus = ldap_modify_s(pLdap, SubscriberDn, Mod); if (LStatus != LDAP_SUCCESS) { printf("ERROR - Can't update %ws: %ws\n", SubscriberDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIBER_OBJ_UPDATE_FAILED; } } } else { printf("No update required\n"); } CLEANUP: FREE(CurMemberRef); FREE(CurRootPath); FREE(CurStagePath); FreeMod(&Mod); return Status; } DWORD CreateNewSubscriber( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName, PWCHAR MemberName, PWCHAR ComputerDn, PWCHAR RootPath, PWCHAR StagePath, PWCHAR WorkingPath, PWCHAR RefDCName ) /*++ Routine Description: Create a new subscriber. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR ReplicaSetDn = NULL; PWCHAR MemberDn = NULL; PWCHAR SubscriberDn = NULL; PWCHAR SubscriptionDn = NULL; PWCHAR MemberAttrs[3]; PWCHAR SubscriberAttrs[3]; PWCHAR SearchFilter = NULL; DWORD NoOfMembers; DWORD NoOfSubscribers; PWCHAR LocalComputerDn = NULL; PLDAPMessage LdapEntry = NULL; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; PWCHAR SaveDn; PWCHAR DFSRoot, DFSJunction; DWORD Vbar; if (bDFSNaming) { Vbar = wcscspn(DFSName, L'|'); if ((Vbar == wcslen(DFSName) || (Vbar == 0)) { // // No vertical bar found. // Status = MKDSOE_BAD_ARG; return Status; } // // Extract the name components. // DFSRoot = FrsWcsDup(DFSName); DFSRoot[Vbar] = L'\0'; DFSJunction = &DFSName[Vbar+1]; } MK_ATTRS_2(MemberAttrs, ATTR_DN, ATTR_COMPUTER_REF); MK_ATTRS_2(SubscriberAttrs, ATTR_DN, ATTR_MEMBER_REF); // // We need to get to the member object and the computer object. // To get to the member object we need the member name or the computer dn. // // To get to the computer object we need a member with valid computerref // or the computerdn parameter. // if ((MemberName == NULL) && (ComputerDn == NULL)) { Status = MKDSOE_BAD_ARG; return Status; } SearchFilter = (PWCHAR) malloc((max((ComputerDn != NULL)?wcslen(ComputerDn):0, (MemberDn != NULL)?wcslen(MemberDn):0) + MAX_PATH) * sizeof(WCHAR)); ReplicaSetDn = ExtendDn(NTFRSSettingsDn, ReplicaSetName); if (MemberName != NULL) { MemberDn = ExtendDn(ReplicaSetDn, MemberName); } else { // // Use computerdn to get the memberdn. // WCS_CAT7(SearchFilter, L"(&(", ATTR_COMPUTER_REF, L"=", ComputerDn, L")" , CLASS_MEMBER, L")"); if (!LdapSearchInit(pLdap, ReplicaSetDn, LDAP_SCOPE_ONELEVEL, SearchFilter, MemberAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if (NoOfMembers == 0) { printf("Error creating subscriber; member not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } if (NoOfMembers > 1) { printf("Error creating subscriber; duplicate members found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_DUPS_FOUND_UPDATE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { MemberDn = FindValue(LdapEntry, ATTR_DN); } LdapSearchClose(&FrsSearchContext); } DPRINT1("MemberDn:%ws\n", MemberDn); if (ComputerDn == NULL) { // // Use MemberDn to find the computerDn. We will come here // only if MemberName is supplied but computerdn is not. // if (!LdapSearchInit(pLdap, MemberDn, LDAP_SCOPE_BASE, NULL, MemberAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if (NoOfMembers == 0) { printf("Error creating subscriber; member not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { LocalComputerDn = FindValue(LdapEntry, ATTR_COMPUTER_REF); if (LocalComputerDn == NULL) { printf("Error creating subscriber; computerdn not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } } LdapSearchClose(&FrsSearchContext); } else { LocalComputerDn = FrsWcsDup(ComputerDn); } // // We have the computerdn and the memberdn. Now check if a subscriber // already exists. // WCS_CAT7(SearchFilter, L"(&(", ATTR_MEMBER_REF, L"=", MemberDn, L")" , CLASS_SUBSCRIBER, L")"); if (!LdapSearchInit(pLdap, LocalComputerDn, LDAP_SCOPE_SUBTREE, SearchFilter, SubscriberAttrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } NoOfSubscribers = FrsSearchContext.EntriesInPage; if (NoOfSubscribers > 1) { printf("Error creating subscriber; duplicate found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SUBSCRIBER_DUPS_FOUND_UPDATE; goto CLEANUP; } if (NoOfSubscribers == 1) { // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { SubscriberDn = FindValue(LdapEntry, ATTR_DN); } Status = UpdateSubscriber(SubscriberDn, MemberDn, RootPath, StagePath); } else { // // Create the new subscriber. // SubscriptionDn = ExtendDn(LocalComputerDn, MKDSOE_SUBSCRIPTION); // ATTR_DN DPRINT1("SubscriptionDn:%ws\n", SubscriptionDn); AddMod(ATTR_CLASS, ATTR_SUBSCRIPTIONS, &Mod); if (WorkingPath != NULL) { // ATTR_WORKING_PATH AddMod(ATTR_REPLICA_STAGE, WorkingPath, &Mod); DPRINT1(" FrsWorkingPath:%ws\n", WorkingPath); } else { fprintf(stderr, "WARNING: Creating subscription '%ws' with no working path\n", MKDSOE_SUBSCRIPTION); } if (bDebugMode) { DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", SubscriptionDn); } else { LStatus = ldap_add_s(pLdap, SubscriptionDn, Mod); if ((LStatus != LDAP_ALREADY_EXISTS) && (LStatus != LDAP_SUCCESS)) { printf("ERROR - Can't create %ws: %ws\n", SubscriptionDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } } FreeMod(&Mod); // // If this member is to be added using the Win2K DFS naming convention // then we need to create a few more subscription containers. E.G. // // (cn=software$|packages, frs subscriber (DFS junction) // cn=software$, frs subscription (DFS Root) // cn=56421f6a-9edd-4098-a101-bf2e161e4572, frs subscription (domain guid for DFS Guid) // cn=dfs volumes, frs subscription // cn=ntfrs subscriptions, frs subscription // cn=dfs-srv-01, computer object // ou=multifunction terminal servers, // ou=domain controllers, // dc=cps, // dc=gov, // dc=uk) // // if (bDFSNaming) { SaveDn = SubscriptionDn; SubscriptionDn = ExtendDn(SubscriptionDn, L"DFS VOLUMES"); FREE(SaveDn); // ATTR_DN DPRINT1("SubscriptionDn:%ws\n", SubscriptionDn); AddMod(ATTR_CLASS, ATTR_SUBSCRIPTIONS, &Mod); if (bDebugMode) { DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", SubscriptionDn); } else { LStatus = ldap_add_s(pLdap, SubscriptionDn, Mod); if ((LStatus != LDAP_ALREADY_EXISTS) && (LStatus != LDAP_SUCCESS)) { printf("ERROR - Can't create %ws: %ws\n", SubscriptionDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } } FreeMod(&Mod); // // Add subscription container with name of Domain Guid. // SaveDn = SubscriptionDn; SubscriptionDn = ExtendDn(SubscriptionDn, DomainGuidStr); FREE(SaveDn); // ATTR_DN DPRINT1("SubscriptionDn:%ws\n", SubscriptionDn); AddMod(ATTR_CLASS, ATTR_SUBSCRIPTIONS, &Mod); if (bDebugMode) { DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", SubscriptionDn); } else { LStatus = ldap_add_s(pLdap, SubscriptionDn, Mod); if ((LStatus != LDAP_ALREADY_EXISTS) && (LStatus != LDAP_SUCCESS)) { printf("ERROR - Can't create %ws: %ws\n", SubscriptionDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } } FreeMod(&Mod); if (wcslen(DFSRoot) > 0) { // // Add subscription container with name of DFS Root. // SaveDn = SubscriptionDn; SubscriptionDn = ExtendDn(SubscriptionDn, DFSRoot); FREE(SaveDn); // ATTR_DN DPRINT1("SubscriptionDn:%ws\n", SubscriptionDn); AddMod(ATTR_CLASS, ATTR_SUBSCRIPTIONS, &Mod); if (bDebugMode) { DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", SubscriptionDn); } else { LStatus = ldap_add_s(pLdap, SubscriptionDn, Mod); if ((LStatus != LDAP_ALREADY_EXISTS) && (LStatus != LDAP_SUCCESS)) { printf("ERROR - Can't create %ws: %ws\n", SubscriptionDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } } FreeMod(&Mod); if (wcslen(DFSJunction) > 0) { // // Add subscription container with name of DFS Junction. // SaveDn = SubscriptionDn; SubscriptionDn = ExtendDn(SubscriptionDn, DFSJunction); FREE(SaveDn); // ATTR_DN DPRINT1("SubscriptionDn:%ws\n", SubscriptionDn); AddMod(ATTR_CLASS, ATTR_SUBSCRIPTIONS, &Mod); if (bDebugMode) { DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", SubscriptionDn); } else { LStatus = ldap_add_s(pLdap, SubscriptionDn, Mod); if ((LStatus != LDAP_ALREADY_EXISTS) && (LStatus != LDAP_SUCCESS)) { printf("ERROR - Can't create %ws: %ws\n", SubscriptionDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } } FreeMod(&Mod); } } } // // Now construct the subscriber object. // SubscriberDn = ExtendDn(SubscriptionDn, ReplicaSetName); // ATTR_DN DPRINT1("SubscriberDn:%ws\n", SubscriberDn); AddMod(ATTR_CLASS, ATTR_SUBSCRIBER, &Mod); // ATTR_MEMBER_REF AddMod(ATTR_MEMBER_REF, MemberDn, &Mod); DPRINT1(" FrsMemberReference:%ws\n", MemberDn); // ATTR_REPLICA_ROOT AddMod(ATTR_REPLICA_ROOT, RootPath, &Mod); DPRINT1(" FrsRootPath:%ws\n", RootPath); // ATTR_REPLICA_STAGE AddMod(ATTR_REPLICA_STAGE, StagePath, &Mod); DPRINT1(" FrsStagePath:%ws\n", StagePath); if (bDebugMode) { DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", SubscriberDn); } else { LStatus = ldap_add_s(pLdap, SubscriberDn, Mod); if ((LStatus == LDAP_CONSTRAINT_VIOLATION) && RefDCName != NULL) { // // prepare the server hint. Needed in case the member object // is just created on another DC than the one on which the // subscriber is being created. // LDAPControl simpleControl; PLDAPControl controlArray[2]; INT rc; BERVAL* pBerVal = NULL; BerElement* pBer; pBer = ber_alloc_t(LBER_USE_DER); if (!pBer) { Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } DPRINT1("Sending binding DC Name %ws\n",RefDCName); rc = ber_printf(pBer,"{io}", 0, RefDCName, wcslen(RefDCName) * sizeof(WCHAR)); if ( rc == -1 ) { Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } rc = ber_flatten(pBer, &pBerVal); if (rc == -1) { Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; goto CLEANUP; } ber_free(pBer,1); controlArray[0] = &simpleControl; controlArray[1] = NULL; // simpleControl.ldctl_oid = LDAP_SERVER_GC_VERIFY_NAME_OID_W; simpleControl.ldctl_oid = LDAP_SERVER_VERIFY_NAME_OID_W; simpleControl.ldctl_iscritical = TRUE; simpleControl.ldctl_value = *pBerVal; LStatus = ldap_add_ext_s(pLdap, SubscriberDn, Mod, (PLDAPControl *)&controlArray, //ServerControls, NULL //ClientControls, ); } 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 objects that have changed. // Status = UpdateSubscriber(SubscriberDn, MemberDn, RootPath, StagePath); } else if (LStatus != LDAP_SUCCESS) { DPRINT2("ERROR - Can't create %ws: %ws\n", SubscriberDn, ldap_err2string(LStatus)); Status = MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED; } } } LdapSearchClose(&FrsSearchContext); CLEANUP: FreeMod(&Mod); FREE(ReplicaSetDn); FREE(MemberDn); FREE(SubscriberDn); FREE(SubscriptionDn); FREE(SearchFilter); FREE(LocalComputerDn); FREE(DFSRoot); return Status; } DWORD DeleteReplicaMember( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName, PWCHAR MemberName, PWCHAR ComputerDn ) /*++ Routine Description: Delete the replica member. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR ReplicaSetDn = NULL; PWCHAR MemberDn = NULL; PWCHAR MemberCn = NULL; PWCHAR ComputerRef = NULL; PWCHAR Attrs[5]; PLDAPMessage LdapEntry = NULL; PWCHAR SearchFilter = NULL; DWORD NoOfMembers; BOOL bNeedsUpdate = FALSE; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; MK_ATTRS_4(Attrs, ATTR_DN, ATTR_CN, ATTR_COMPUTER_REF, ATTR_SERVER_REF); SearchFilter = (PWCHAR) malloc((((ComputerDn != NULL)?wcslen(ComputerDn):0) + MAX_PATH) * sizeof(WCHAR)); ReplicaSetDn = ExtendDn(NTFRSSettingsDn, ReplicaSetName); if (MemberName != NULL) { WCS_CAT7(SearchFilter, L"(&(", ATTR_CN, L"=", MemberName, L")" , CLASS_MEMBER, L")"); } else if (ComputerDn != NULL){ WCS_CAT7(SearchFilter, L"(&(", ATTR_COMPUTER_REF, L"=", ComputerDn, L")" , CLASS_MEMBER, L")"); } else { wcscpy(SearchFilter, CLASS_MEMBER); } if (!LdapSearchInit(pLdap, ReplicaSetDn, LDAP_SCOPE_ONELEVEL, SearchFilter, Attrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_MEMBER_DELETE_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if ((NoOfMembers > 1) && (bAffectAll != TRUE)) { DPRINT0("Duplicate members found. Deleting all.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_MEMBER_DUPS_FOUND_DELETE; goto CLEANUP; } if (NoOfMembers != 0) { // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { MemberDn = FindValue(LdapEntry, ATTR_DN); MemberCn = FindValue(LdapEntry, ATTR_CN); ComputerRef = FindValue(LdapEntry, ATTR_COMPUTER_REF); // // If asked to delete the corresponding subscriber then do that first. // if (bDelSubscriber && ((ComputerRef != NULL) || (ComputerDn != NULL))) { Status = DeleteSubscriber(NTFRSSettingsDn, ReplicaSetName, MemberCn, (ComputerRef != NULL)?ComputerRef:ComputerDn); if (Status != MKDSOE_SUCCESS) { LdapSearchClose(&FrsSearchContext); goto CLEANUP; } } DPRINT1("Deleting Dn:%ws\n", MemberDn); if (bDebugMode) { DPRINT1("LStatus = ldap_delete_s(pLdap, %ws);\n", MemberDn); } else { LStatus = ldap_delete_s(pLdap, MemberDn); if (LStatus != LDAP_SUCCESS) { DPRINT2("ERROR - Can't delete %ws: %ws\n", MemberDn, ldap_err2string(LStatus)); Status = MKDSOE_MEMBER_DELETE_FAILED; } } FREE(MemberDn); FREE(MemberCn); FREE(ComputerRef); } } else { DPRINT0("Warning deleting; member not found.\n"); Status = MKDSOE_MEMBER_NOT_FOUND_DELETE; } LdapSearchClose(&FrsSearchContext); CLEANUP: FreeMod(&Mod); FREE(ReplicaSetDn); FREE(MemberDn); FREE(MemberCn); FREE(ComputerRef); FREE(SearchFilter); return Status; } DWORD UpdateReplicaMember( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName, PWCHAR MemberName, PWCHAR ComputerDn, PWCHAR ServerRef, PWCHAR RefDCName ) /*++ Routine Description: Update the replica member parameters. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR ReplicaSetDn = NULL; PWCHAR MemberDn = NULL; PWCHAR Attrs[4]; PLDAPMessage LdapEntry = NULL; PWCHAR SearchFilter = NULL; PWCHAR CurComputerRef = NULL; PWCHAR CurServerRef = NULL; DWORD NoOfMembers; BOOL bNeedsUpdate = FALSE; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; MK_ATTRS_3(Attrs, ATTR_DN, ATTR_COMPUTER_REF, ATTR_SERVER_REF); SearchFilter = (PWCHAR) malloc((((ComputerDn != NULL)?wcslen(ComputerDn):0) + MAX_PATH) * sizeof(WCHAR)); ReplicaSetDn = ExtendDn(NTFRSSettingsDn, ReplicaSetName); if (MemberName != NULL) { WCS_CAT7(SearchFilter, L"(&(", ATTR_CN, L"=", MemberName, L")" , CLASS_MEMBER, L")"); } else { WCS_CAT7(SearchFilter, L"(&(", ATTR_COMPUTER_REF, L"=", ComputerDn, L")" , CLASS_MEMBER, L")"); } if (!LdapSearchInit(pLdap, ReplicaSetDn, LDAP_SCOPE_ONELEVEL, SearchFilter, Attrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_MEMBER_OBJ_UPDATE_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if (NoOfMembers == 0) { DPRINT0("Error updating; member not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_MEMBER_NOT_FOUND_UPDATE; goto CLEANUP; } if (NoOfMembers > 1) { DPRINT0("Error updating; duplicate members found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_MEMBER_DUPS_FOUND_UPDATE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { MemberDn = FindValue(LdapEntry, ATTR_DN); CurComputerRef = FindValue(LdapEntry, ATTR_COMPUTER_REF); CurServerRef = FindValue(LdapEntry, ATTR_SERVER_REF); } LdapSearchClose(&FrsSearchContext); DPRINT1("MemberDn:%ws\n", MemberDn); // Check ATTR_COMPUTER_REF // if a ref is supplied then make sure it is same as the current ref. // if a ref is not supplied then leave it as it is. if (ComputerDn != NULL) { if ((CurComputerRef == NULL) || ((CurComputerRef != NULL) && wcscmp(ComputerDn, CurComputerRef))) { AddMod(ATTR_COMPUTER_REF, ComputerDn, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsComputerReference:%ws\n", ComputerDn); } } // Check ATTR_SERVER_REF // if a ref is supplied then make sure it is same as the current ref. // if a ref is not supplied then leave it as it is. if (ServerRef != NULL) { if ((CurServerRef == NULL) || ((CurServerRef != NULL) && wcscmp(ServerRef, CurServerRef))) { AddMod(ATTR_SERVER_REF, ServerRef, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New ServerReference:%ws\n", ServerRef); } } if (bNeedsUpdate) { if (bDebugMode) { DPRINT1("LStatus = ldap_modify_s(pLdap, %ws, Mod);\n", MemberDn); } else { LStatus = ldap_modify_s(pLdap, MemberDn, Mod); if ((LStatus == LDAP_CONSTRAINT_VIOLATION) && RefDCName != NULL) { // // prepare the server hint. Needed in case the member object // is just created on another DC than the one on which the // subscriber is being created. // LDAPControl simpleControl; PLDAPControl controlArray[2]; INT rc; BERVAL* pBerVal = NULL; BerElement* pBer; pBer = ber_alloc_t(LBER_USE_DER); if (!pBer) { Status = MKDSOE_MEMBER_OBJ_UPDATE_FAILED; goto CLEANUP; } DPRINT1("Sending binding DC Name %ws\n",RefDCName); rc = ber_printf(pBer,"{io}", 0, RefDCName, wcslen(RefDCName) * sizeof(WCHAR)); if ( rc == -1 ) { Status = MKDSOE_MEMBER_OBJ_UPDATE_FAILED; goto CLEANUP; } rc = ber_flatten(pBer, &pBerVal); if (rc == -1) { Status = MKDSOE_MEMBER_OBJ_UPDATE_FAILED; goto CLEANUP; } ber_free(pBer,1); controlArray[0] = &simpleControl; controlArray[1] = NULL; // simpleControl.ldctl_oid = LDAP_SERVER_GC_VERIFY_NAME_OID_W; simpleControl.ldctl_oid = LDAP_SERVER_VERIFY_NAME_OID_W; simpleControl.ldctl_iscritical = TRUE; simpleControl.ldctl_value = *pBerVal; LStatus = ldap_modify_ext_s(pLdap, MemberDn, Mod, (PLDAPControl *)&controlArray, //ServerControls, NULL //ClientControls, ); } if (LStatus != LDAP_SUCCESS) { DPRINT2("ERROR - Can't update %ws: %ws\n", MemberDn, ldap_err2string(LStatus)); Status = MKDSOE_MEMBER_OBJ_UPDATE_FAILED; } } } else { DPRINT0("No update required\n"); } if (bMakeMePrimary && (Status == MKDSOE_SUCCESS)) { // // Update the primary member attribute on the replica set object to // reference this member if /makemeprimary is set. // Status = UpdateReplicaSet(NTFRSSettingsDn, ReplicaSetName, NULL, NULL, NULL, MemberName, NULL); } CLEANUP: FreeMod(&Mod); FREE(ReplicaSetDn); FREE(MemberDn); FREE(SearchFilter); FREE(CurComputerRef); FREE(CurServerRef); return Status; } DWORD CreateNewReplicaMember( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName, PWCHAR MemberName, PWCHAR ComputerDn, PWCHAR ServerRef, PWCHAR RefDCName ) /*++ Routine Description: Create a new replica member. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR ReplicaSetDn = NULL; PWCHAR MemberDn = NULL; ReplicaSetDn = ExtendDn(NTFRSSettingsDn, ReplicaSetName); MemberDn = ExtendDn(ReplicaSetDn, MemberName); // ATTR_DN DPRINT1("MemberDn:%ws\n", MemberDn); AddMod(ATTR_CLASS, ATTR_MEMBER, &Mod); // ATTR_COMPUTER_REF if (ComputerDn != NULL) { AddMod(ATTR_COMPUTER_REF, ComputerDn, &Mod); DPRINT1(" FrsComputerReference:%ws\n", ComputerDn); } // ATTR_SERVER_REF if (ServerRef != NULL) { AddMod(ATTR_SERVER_REF, ServerRef, &Mod); DPRINT1(" ServerReference:%ws\n", ServerRef); } if (bDebugMode) { DPRINT1("LStatus = ldap_add_s(pLdap, %ws, Mod);\n", MemberDn); } else { LStatus = ldap_add_s(pLdap, MemberDn, Mod); if ((LStatus == LDAP_CONSTRAINT_VIOLATION) && RefDCName != NULL) { // // prepare the server hint. Needed in case the member object // is just created on another DC than the one on which the // subscriber is being created. // LDAPControl simpleControl; PLDAPControl controlArray[2]; INT rc; BERVAL* pBerVal = NULL; BerElement* pBer; pBer = ber_alloc_t(LBER_USE_DER); if (!pBer) { Status = MKDSOE_MEMBER_OBJ_CRE_FAILED; goto CLEANUP; } DPRINT1("Sending binding DC Name %ws\n",RefDCName); rc = ber_printf(pBer,"{io}", 0, RefDCName, wcslen(RefDCName) * sizeof(WCHAR)); if ( rc == -1 ) { Status = MKDSOE_MEMBER_OBJ_CRE_FAILED; goto CLEANUP; } rc = ber_flatten(pBer, &pBerVal); if (rc == -1) { Status = MKDSOE_MEMBER_OBJ_CRE_FAILED; goto CLEANUP; } ber_free(pBer,1); controlArray[0] = &simpleControl; controlArray[1] = NULL; // simpleControl.ldctl_oid = LDAP_SERVER_GC_VERIFY_NAME_OID_W; simpleControl.ldctl_oid = LDAP_SERVER_VERIFY_NAME_OID_W; simpleControl.ldctl_iscritical = TRUE; simpleControl.ldctl_value = *pBerVal; LStatus = ldap_add_ext_s(pLdap, MemberDn, Mod, (PLDAPControl *)&controlArray, //ServerControls, NULL //ClientControls, ); } 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 objects that have changed. // Status = UpdateReplicaMember(NTFRSSettingsDn, ReplicaSetName, MemberName, ComputerDn, ServerRef, RefDCName); } else if (LStatus != LDAP_SUCCESS) { DPRINT2("ERROR - Can't create %ws: %ws\n", MemberDn, ldap_err2string(LStatus)); Status = MKDSOE_MEMBER_OBJ_CRE_FAILED; } else if (bMakeMePrimary) { // // Update the primary member attribute on the replica set object to // reference this member if /makemeprimary is set. // Status = UpdateReplicaSet(NTFRSSettingsDn, ReplicaSetName, NULL, NULL, NULL, MemberName, NULL); } } CLEANUP: FreeMod(&Mod); FREE(ReplicaSetDn); FREE(MemberDn); return Status; } DWORD DeleteReplicaSet( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName ) /*++ Routine Description: delete replica set. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR ReplicaSetDn = NULL; PWCHAR Attrs[2]; PLDAPMessage LdapEntry = NULL; WCHAR SearchFilter[MAX_PATH]; DWORD NoOfSets; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; MK_ATTRS_1(Attrs, ATTR_DN); WCS_CAT7(SearchFilter, L"(&(", ATTR_CN, L"=", ReplicaSetName, L")" , CLASS_NTFRS_REPLICA_SET, L")"); if (!LdapSearchInit(pLdap, NTFRSSettingsDn, LDAP_SCOPE_SUBTREE, SearchFilter, Attrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SET_DELETE_FAILED; goto CLEANUP; } NoOfSets = FrsSearchContext.EntriesInPage; if (NoOfSets == 0) { DPRINT0("Error deleting; connection not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SET_NOT_FOUND_DELETE; goto CLEANUP; } if (NoOfSets > 1) { DPRINT0("Error deleting; duplicate sets found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SET_DUPS_FOUND_DELETE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { ReplicaSetDn = FindValue(LdapEntry, ATTR_DN); DPRINT1("Deleting Dn:%ws\n", ReplicaSetDn); if (bDebugMode) { DPRINT1("LStatus = ldap_delete_s(pLdap, %ws);\n", ReplicaSetDn); } else { LStatus = ldap_delete_s(pLdap, ReplicaSetDn); if (LStatus != LDAP_SUCCESS) { DPRINT2("ERROR - Can't delete %ws: %ws\n", ReplicaSetDn, ldap_err2string(LStatus)); Status = MKDSOE_SET_DELETE_FAILED; } } } LdapSearchClose(&FrsSearchContext); CLEANUP: FreeMod(&Mod); FREE(ReplicaSetDn); return Status; } DWORD UpdateReplicaSet( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName, PWCHAR ReplicaSetType, PWCHAR FileFilter, PWCHAR DirectoryFilter, PWCHAR PrimaryMember, PBYTE pSchedule ) /*++ Routine Description: Update the replica set parameters. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR ReplicaSetDn = NULL; PWCHAR Attrs[7]; PLDAPMessage LdapEntry = NULL; WCHAR SearchFilter[MAX_PATH]; PWCHAR CurSetType = NULL; PWCHAR CurFileFilter = NULL; PWCHAR CurDirectoryFilter = NULL; PWCHAR CurPrimaryMember = NULL; PWCHAR PrimaryMemberDn = NULL; DWORD NoOfSets; PSCHEDULE Schedule = NULL; DWORD ScheduleLen; BOOL bNeedsUpdate = FALSE; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; MK_ATTRS_6(Attrs, ATTR_DN, ATTR_SET_TYPE, ATTR_FILE_FILTER, ATTR_DIRECTORY_FILTER, ATTR_SCHEDULE, ATTR_PRIMARY_MEMBER); WCS_CAT7(SearchFilter, L"(&(", ATTR_CN, L"=", ReplicaSetName, L")" , CLASS_NTFRS_REPLICA_SET, L")"); if (!LdapSearchInit(pLdap, NTFRSSettingsDn, LDAP_SCOPE_SUBTREE, SearchFilter, Attrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SET_OBJ_UPDATE_FAILED; goto CLEANUP; } NoOfSets = FrsSearchContext.EntriesInPage; if (NoOfSets == 0) { DPRINT0("Error updating; connection not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SET_NOT_FOUND_UPDATE; goto CLEANUP; } if (NoOfSets > 1) { DPRINT0("Error updating; duplicate connections found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SET_DUPS_FOUND_UPDATE; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { ReplicaSetDn = FindValue(LdapEntry, ATTR_DN); CurSetType = FindValue(LdapEntry, ATTR_SET_TYPE); CurFileFilter = FindValue(LdapEntry, ATTR_FILE_FILTER); CurDirectoryFilter = FindValue(LdapEntry, ATTR_DIRECTORY_FILTER); CurPrimaryMember = FindValue(LdapEntry, ATTR_PRIMARY_MEMBER); FindBerValue(LdapEntry, ATTR_SCHEDULE, &ScheduleLen, (VOID **)&Schedule); } LdapSearchClose(&FrsSearchContext); DPRINT1("ReplicaSetDn:%ws\n", ReplicaSetDn); // Check ATTR_SET_TYPE // if a type is supplied then make sure it is same as the current type. // if a type is not supplied then leave it as it is. if (ReplicaSetType != NULL) { if ((CurSetType == NULL) || ((CurSetType != NULL) && wcscmp(ReplicaSetType, CurSetType))) { AddMod(ATTR_SET_TYPE, ReplicaSetType, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsReplicaSetType:%ws\n", ReplicaSetType); } } // Check ATTR_FILE_FILTER // if a filter is supplied then make sure it is same as the current filter. // if a filter is not supplied then leave it as it is. if (FileFilter != NULL) { if ((CurFileFilter == NULL) || ((CurFileFilter != NULL) && wcscmp(FileFilter, CurFileFilter))) { AddMod(ATTR_FILE_FILTER, FileFilter, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsFileFilter:%ws\n", FileFilter); } } // Check ATTR_DIRECTORY_FILTER // if a filter is supplied then make sure it is same as the current filter. // if a filter is not supplied then leave it as it is. if (DirectoryFilter != NULL) { if ((CurDirectoryFilter == NULL) || ((CurDirectoryFilter != NULL) && wcscmp(DirectoryFilter, CurDirectoryFilter))) { AddMod(ATTR_DIRECTORY_FILTER, DirectoryFilter, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsDirectoryFilter:%ws\n", DirectoryFilter); } } // Check ATTR_PRIMARY_MEMBER // if a PrimaryMember is supplied then make sure it is same as the current PrimaryMember. // if a PrimaryMember is not supplied then leave it as it is. if (PrimaryMember != NULL) { PrimaryMemberDn = ExtendDn(ReplicaSetDn, PrimaryMember); if ((CurPrimaryMember == NULL) || ((CurPrimaryMember != NULL) && wcscmp(PrimaryMemberDn, CurPrimaryMember))) { AddMod(ATTR_PRIMARY_MEMBER, PrimaryMemberDn, &Mod); bNeedsUpdate = TRUE; DPRINT1(" New FrsPrimaryMember:%ws\n", PrimaryMemberDn); } } // 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", ReplicaSetDn); } else { LStatus = ldap_modify_s(pLdap, ReplicaSetDn, Mod); if (LStatus != LDAP_SUCCESS) { DPRINT2("ERROR - Can't update %ws: %ws\n", ReplicaSetDn, ldap_err2string(LStatus)); Status = MKDSOE_SET_OBJ_UPDATE_FAILED; } } } else { DPRINT0("No update required\n"); } CLEANUP: FreeMod(&Mod); FREE(ReplicaSetDn); FREE(PrimaryMemberDn); FREE(CurSetType); FREE(CurFileFilter); FREE(CurDirectoryFilter); FREE(CurPrimaryMember); FREE(Schedule); return Status; } DWORD CreateNewReplicaSet( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName, PWCHAR ReplicaSetType, PWCHAR FileFilter, PWCHAR DirectoryFilter, PWCHAR PrimaryMember, PBYTE pSchedule ) /*++ Routine Description: Create a new replica Set. Arguments: Return Value: --*/ { LDAPMod **Mod = NULL; DWORD LStatus = LDAP_SUCCESS; DWORD Status = MKDSOE_SUCCESS; PWCHAR ReplicaSetDn = NULL; PWCHAR PrimaryMemberDn = NULL; UINT i; ReplicaSetDn = ExtendDn(NTFRSSettingsDn, ReplicaSetName); // ATTR_DN DPRINT1("ReplicaSetDn:%ws\n", ReplicaSetDn); AddMod(ATTR_CLASS, ATTR_REPLICA_SET, &Mod); // ATTR_SET_TYPE AddMod(ATTR_SET_TYPE, ReplicaSetType, &Mod); DPRINT1(" FrsReplicaSetType:%ws\n", ReplicaSetType); // ATTR_FILE_FILTER if (FileFilter != NULL) { AddMod(ATTR_FILE_FILTER, FileFilter, &Mod); DPRINT1(" FrsFileFilter:%ws\n", FileFilter); } // ATTR_DIRECTORY_FILTER if (DirectoryFilter != NULL) { AddMod(ATTR_DIRECTORY_FILTER, DirectoryFilter, &Mod); DPRINT1(" FrsDirectoryFilter:%ws\n", DirectoryFilter); } // ATTR_PRIMARY_MEMBER if (PrimaryMember != NULL) { PrimaryMemberDn = ExtendDn(ReplicaSetDn, PrimaryMember); AddMod(ATTR_PRIMARY_MEMBER, PrimaryMemberDn, &Mod); DPRINT1(" FrsPrimaryMemberr:%ws\n", PrimaryMemberDn); } 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", ReplicaSetDn); } else { LStatus = ldap_add_s(pLdap, ReplicaSetDn, 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 objects that have changed. // Status = UpdateReplicaSet(NTFRSSettingsDn, ReplicaSetName, ReplicaSetType, FileFilter, DirectoryFilter, PrimaryMember, pSchedule); } else if (LStatus != LDAP_SUCCESS) { DPRINT2("ERROR - Can't create %ws: %ws\n", ReplicaSetDn, ldap_err2string(LStatus)); Status = MKDSOE_SET_OBJ_CRE_FAILED; } } FreeMod(&Mod); FREE(ReplicaSetDn); FREE(PrimaryMemberDn); 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); } } } DWORD DumpSubscribers( PWCHAR ComputerDn, PWCHAR MemberDn ) /*++ Routine Description: Dump the frs member object. Arguments: Return Value: --*/ { DWORD LStatus; DWORD Status = MKDSOE_SUCCESS; PWCHAR Attrs[5]; PLDAPMessage LdapEntry = NULL; PWCHAR Val = NULL; PWCHAR SearchFilter = NULL; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; DWORD NoOfSubscribers; MK_ATTRS_4(Attrs, ATTR_DN, ATTR_MEMBER_REF, ATTR_REPLICA_ROOT, ATTR_REPLICA_STAGE); SearchFilter = (PWCHAR) malloc((((MemberDn != NULL)?wcslen(MemberDn):0) + MAX_PATH) * sizeof(WCHAR)); if (MemberDn != NULL) { WCS_CAT7(SearchFilter, L"(&(", ATTR_MEMBER_REF, L"=", MemberDn, L")" , CLASS_SUBSCRIBER, L")"); } else { wcscpy(SearchFilter, CLASS_SUBSCRIBER); } if (!LdapSearchInit(pLdap, ComputerDn, LDAP_SCOPE_SUBTREE, SearchFilter, Attrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SUBSCRIBER_DUMP_FAILED; goto CLEANUP; } NoOfSubscribers = FrsSearchContext.EntriesInPage; if (NoOfSubscribers == 0) { LdapSearchClose(&FrsSearchContext); if (MemberDn != NULL) { // // This error return only makes sense when we were asked to dump // a specific subscriber. // DPRINT0("Error dumping; subscriber not found.\n"); Status = MKDSOE_SUBSCRIBER_NOT_FOUND_DUMP; } goto CLEANUP; } // // 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("\n SubscriberDn:%ws\n", Val); FREE(Val); // // ATTR_CLASS // We know the class printf(" ObjectClass:nTFRSSubscriber\n"); // ATTR_MEMBER_REF Val = FindValue(LdapEntry, ATTR_MEMBER_REF); printf(" FrsMemberReference:%ws\n", Val); FREE(Val); // ATTR_REPLICA_ROOT Val = FindValue(LdapEntry, ATTR_REPLICA_ROOT); printf(" FrsRootPath:%ws\n", Val); FREE(Val); // ATTR_REPLICA_STAGE Val = FindValue(LdapEntry, ATTR_REPLICA_STAGE); printf(" FrsStagingPath:%ws\n", Val); FREE(Val); } LdapSearchClose(&FrsSearchContext); CLEANUP: FREE(SearchFilter); return Status; } DWORD DumpReplicaMembers( PWCHAR NTFRSReplicaSetDn, PWCHAR MemberName ) /*++ Routine Description: Dump the frs member object. Arguments: Return Value: --*/ { DWORD LStatus; DWORD Status = MKDSOE_SUCCESS; PWCHAR Attrs[4]; PLDAPMessage LdapEntry = NULL; PWCHAR Val = NULL; PWCHAR ComputerRef = NULL; PWCHAR MemberDn = NULL; WCHAR SearchFilter[MAX_PATH]; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; DWORD NoOfMembers; MK_ATTRS_3(Attrs, ATTR_DN, ATTR_COMPUTER_REF, ATTR_SERVER_REF); if (MemberName != NULL) { WCS_CAT7(SearchFilter, L"(&(", ATTR_CN, L"=", MemberName, L")" , CLASS_MEMBER, L")"); } else { wcscpy(SearchFilter, CLASS_MEMBER); } if (!LdapSearchInit(pLdap, NTFRSReplicaSetDn, LDAP_SCOPE_ONELEVEL, SearchFilter, Attrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_MEMBER_DUMP_FAILED; goto CLEANUP; } NoOfMembers = FrsSearchContext.EntriesInPage; if (NoOfMembers == 0) { LdapSearchClose(&FrsSearchContext); if (MemberName != NULL) { // // This error return only makes sense when we were asked to dump // a specific member object. // DPRINT0("Error dumping; member not found.\n"); Status = MKDSOE_MEMBER_NOT_FOUND_DUMP; } goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { // ATTR_DN MemberDn = FindValue(LdapEntry, ATTR_DN); printf("\n MemberDn:%ws\n", MemberDn); // // ATTR_CLASS // We know the class printf(" ObjectClass:nTFRSMember\n"); // ATTR_COMPUTER_REF ComputerRef = FindValue(LdapEntry, ATTR_COMPUTER_REF); printf(" FrsComputerReference:%ws\n", ComputerRef); // ATTR_SERVER_REF Val = FindValue(LdapEntry, ATTR_SERVER_REF); printf(" ServerReference:%ws\n", Val); FREE(Val); if (bAffectAll && ComputerRef != NULL) { DumpSubscribers(ComputerRef, MemberDn); } FREE(ComputerRef); FREE(MemberDn); } LdapSearchClose(&FrsSearchContext); CLEANUP: return Status; } DWORD DumpReplicaSet( PWCHAR NTFRSSettingsDn, PWCHAR ReplicaSetName ) /*++ Routine Description: Dump the replica set object. Arguments: Return Value: --*/ { DWORD LStatus; DWORD Status = MKDSOE_SUCCESS; PWCHAR Attrs[7]; PLDAPMessage LdapEntry = NULL; PWCHAR Val = NULL; PWCHAR ReplicaSetDn = NULL; WCHAR SearchFilter[MAX_PATH]; FRS_LDAP_SEARCH_CONTEXT FrsSearchContext; DWORD ReplicaSetType; DWORD NoOfSets; DWORD ScheduleLen; PSCHEDULE Schedule = NULL; BOOL SaveVerbose; MK_ATTRS_6(Attrs, ATTR_DN, ATTR_SET_TYPE, ATTR_FILE_FILTER, ATTR_DIRECTORY_FILTER, ATTR_SCHEDULE, ATTR_PRIMARY_MEMBER); if (ReplicaSetName != NULL) { WCS_CAT7(SearchFilter, L"(&(", ATTR_CN, L"=", ReplicaSetName, L")" , CLASS_NTFRS_REPLICA_SET, L")"); } else { wcscpy(SearchFilter, CLASS_NTFRS_REPLICA_SET); } if (!LdapSearchInit(pLdap, NTFRSSettingsDn, LDAP_SCOPE_SUBTREE, SearchFilter, Attrs, 0, &FrsSearchContext, FALSE)) { Status = MKDSOE_SET_DUMP_FAILED; goto CLEANUP; } NoOfSets = FrsSearchContext.EntriesInPage; if (NoOfSets == 0) { DPRINT0("Error dumping; replica set not found.\n"); LdapSearchClose(&FrsSearchContext); Status = MKDSOE_SET_NOT_FOUND_DUMP; goto CLEANUP; } // // Scan the entries returned from ldap_search // for (LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext); LdapEntry != NULL; LdapEntry = LdapSearchNext(pLdap, &FrsSearchContext)) { // ATTR_DN ReplicaSetDn = FindValue(LdapEntry, ATTR_DN); printf("\nReplicaSetDn:%ws\n", ReplicaSetDn); // // ATTR_CLASS // We know the class printf(" ObjectClass:nTFRSReplicaSet\n"); // ATTR_SET_TYPE Val = FindValue(LdapEntry, ATTR_SET_TYPE); ReplicaSetType = _wtoi(Val); printf(" FrsReplicaSetType:%ws ", Val); if (ReplicaSetType > MKDSOE_RSTYPE_MAX) { printf("[ Invalid Type "); } else { printf("[ %ws ", ReplicaSetTypeStr[ReplicaSetType]); } printf("]\n"); FREE(Val); // ATTR_FILE_FILTER Val = FindValue(LdapEntry, ATTR_FILE_FILTER); printf(" FrsFileFilter:%ws\n", Val); FREE(Val); // ATTR_DIRECTORY_FILTER Val = FindValue(LdapEntry, ATTR_DIRECTORY_FILTER); printf(" FrsDirectoryFilter:%ws\n", Val); FREE(Val); // ATTR_PRIMARY_MEMBER Val = FindValue(LdapEntry, ATTR_PRIMARY_MEMBER); printf(" FrsPrimaryMember:%ws\n", Val); FREE(Val); // ATTR_SCHEDULE FindBerValue(LdapEntry, ATTR_SCHEDULE, &ScheduleLen, (VOID **)&Schedule); if (Schedule) { SaveVerbose = bVerboseMode; bVerboseMode = TRUE; PrintSchedule(Schedule, 0x0F); bVerboseMode = SaveVerbose; delete(Schedule); } // // Dump the members if asked. // if (bAffectAll) { DumpReplicaMembers(ReplicaSetDn, NULL); } FREE(ReplicaSetDn); } LdapSearchClose(&FrsSearchContext); CLEANUP: return Status; } 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("\n"); printf("%-60s\n", "This tool creates, adds, updates, dumps, and deletes replica set, member, and subscriber objects.\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 /ntfrssettingsdn\n", "Dn for the FRS settings container.", Argv[0]); printf("%-60s%ws /setname\n", "Name of the replica set.", Argv[0]); printf("%-60s%ws /settype\n", "Type of the replica set.", Argv[0]); printf("%-60s\n", "Sysvol = 2"); printf("%-60s\n", "Dfs = 3"); printf("%-60s\n\n", "Other = 4"); printf("%-60s%ws /filefilter\n", "Filter to use against files.e.g. *.bak,*.tmp", Argv[0]); printf("%-60s%ws /directoryfilter\n", "Filter to use against directories.", Argv[0]); printf("%-60s%ws /primarymember\n", "Name of primary member for initial replica set contents.", Argv[0]); printf("%-60s%ws /membername\n", "Name of the member.", Argv[0]); printf("%-60s\n", "If DFS naming conventions are desired, specify 'ComputerObjectGuid' for membername."); printf("%-60s%ws /dfsname\n", "Name of the dfs in the format |.", Argv[0]); printf("%-60s\n", "Required if membername is 'ComputerObjectGuid'."); printf("%-60s%ws /computerdn\n", "Dn for the computer object.", Argv[0]); printf("%-60s%ws /computername\n", "NT4 style computer name. e.g. NTDEV\\SUDARCTEST$.", Argv[0]); printf("%-60s%ws /serverref\n", "Dn of NTDSSettings object for DCs.", Argv[0]); printf("%-60s%ws /rootpath\n", "Replica root path. Has to be absolute.", Argv[0]); printf("%-60s%ws /stagepath\n", "Replica staging path. Has to be absolute.", Argv[0]); printf("%-60s%ws /workingpath\n", "Replica working path. Has to be absolute. Only used if subscriptions obj created.", Argv[0]); printf("%-60s%ws /refdcname \n", "Reference DC to use while creating subscriber.", Argv[0]); printf("%-60s%ws /[create update del dump]\n", "Operation to be performed.", Argv[0]); printf("%-60s%ws \n\n", " can be one of [set member subscriber].", Argv[0]); printf("%-60s%ws /all\n", "Perform the operation on all the objects.", Argv[0]); printf("%-60s%ws \n\n", "/all only works with /dump and /del.", Argv[0]); printf("%-60s%ws /makemeprimary\n", "Make this member object the primary replica set member.", Argv[0]); printf("%-60s%ws \n\n", "Applies to member operations only.", Argv[0]); printf("%-60s%ws /schedule \n", "Schedule to create for the replica set.", Argv[0]); printf("%-60s%ws \n", "The desired interval between each sync with one source.", Argv[0]); printf("%-60s%ws \n", "Typically number of source DCs.", Argv[0]); printf("%-60s%ws \n\n", "Typically the number of the source DC.", 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", "SchedOverride and SchedMask data are formatted"); printf("%-60s\n\n", "as 2 ascii hex digits for each schedule byte."); DPRINT0("\n"); DPRINT0("mkdso.exe error return codes\n"); DPRINT0("100 = Success\n"); DPRINT0("101 = Invalid Arguments\n"); DPRINT0("102 = Could not bind to the DC\n"); DPRINT0("103 = Could not find 'NTFRS Settings' object. Check the /settingsdn parameter\n"); DPRINT0("104 = Error creating replica set\n"); DPRINT0("105 = Error updating replica set\n"); DPRINT0("106 = Error updating replica set; set not found\n"); DPRINT0("107 = Error updating replica set; duplicate sets found\n"); DPRINT0("108 = Error deleting replica set; duplicate sets found.\n"); DPRINT0("109 = Error deleting replica set\n"); DPRINT0("110 = Error deleting replica set; set not found\n"); DPRINT0("111 = Deleting multiple sets\n"); DPRINT0("112 = Error dumping replica set\n"); DPRINT0("113 = Error dumping replica set; set not found\n"); DPRINT0("114 = Dumping duplicate sets\n"); DPRINT0("115 = Error creating replica member\n"); DPRINT0("116 = Error updating replica member\n"); DPRINT0("117 = Error updating replica member; member not found\n"); DPRINT0("118 = Error updating replica member; duplicate members found\n"); DPRINT0("119 = Error deleting member; duplicate subscribers found.\n"); DPRINT0("120 = Error deleting replica member\n"); DPRINT0("121 = Error deleting replica member; member not found\n"); DPRINT0("122 = Deleting multiple members\n"); DPRINT0("123 = Error dumping replica member\n"); DPRINT0("124 = Error dumping replica member; member not found\n"); DPRINT0("125 = Dumping duplicate members\n"); DPRINT0("126 = Error creating subscriber\n"); DPRINT0("127 = Error updating subscriber\n"); DPRINT0("128 = Error updating subscriber; subscriber not found\n"); DPRINT0("129 = Error updating subscriber; duplicate subscribers found\n"); DPRINT0("130 = Error deleting subscriber\n"); DPRINT0("131 = Error deleting subscriber; subscriber not found\n"); DPRINT0("132 = Deleting multiple subscribers\n"); DPRINT0("133 = Error deleting subscriber; duplicate subscribers found.\n"); DPRINT0("134 = Error dumping subscriber\n"); DPRINT0("135 = Error dumping subscriber; subscriber not found\n"); DPRINT0("136 = Dumping duplicate subscribers\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. MKDSOE_SUCCESS "Success." MKDSOE_BAD_ARG "Invalid Arguments." MKDSOE_CANT_BIND "Could not bind to the DC." MKDSOE_NO_NTFRS_SETTINGS "Could not find 'NTFRS Settings' object. Check the /settingsdn parameter." MKDSOE_SET_OBJ_CRE_FAILED "Error creating replica set." MKDSOE_SET_OBJ_UPDATE_FAILED "Error updating replica set." MKDSOE_SET_NOT_FOUND_UPDATE "Error updating replica set; set not found." MKDSOE_SET_DUPS_FOUND_UPDATE "Error updating replica set; duplicate sets found." MKDSOE_SET_DUPS_FOUND_DELETE "Error deleting replica set; duplicate sets found." MKDSOE_SET_DELETE_FAILED "Error deleting replica set." MKDSOE_SET_NOT_FOUND_DELETE "Error deleting replica set; set not found." MKDSOE_MULTIPLE_SETS_DELETED "Deleting multiple sets." MKDSOE_SET_DUMP_FAILED "Error dumping replica set." MKDSOE_SET_NOT_FOUND_DUMP "Error dumping replica set; set not found." MKDSOE_MULTIPLE_SETS_DUMPED "Dumping duplicate sets." MKDSOE_MEMBER_OBJ_CRE_FAILED "Error creating replica member." MKDSOE_MEMBER_OBJ_UPDATE_FAILED "Error updating replica member." MKDSOE_MEMBER_NOT_FOUND_UPDATE "Error updating replica member; member not found." MKDSOE_MEMBER_DUPS_FOUND_UPDATE "Error updating replica member; duplicate members found." MKDSOE_MEMBER_DUPS_FOUND_DELETE "Error deleting member; duplicate subscribers found." MKDSOE_MEMBER_DELETE_FAILED "Error deleting replica member." MKDSOE_MEMBER_NOT_FOUND_DELETE "Error deleting replica member; member not found." MKDSOE_MULTIPLE_MEMBERS_DELETED "Deleting multiple members." MKDSOE_MEMBER_DUMP_FAILED "Error dumping replica member." MKDSOE_MEMBER_NOT_FOUND_DUMP "Error dumping replica member; member not found." MKDSOE_MULTIPLE_MEMBERS_DUMPED "Dumping duplicate members." MKDSOE_SUBSCRIBER_OBJ_CRE_FAILED "Error creating subscriber." MKDSOE_SUBSCRIBER_OBJ_UPDATE_FAILED "Error updating subscriber." MKDSOE_SUBSCRIBER_NOT_FOUND_UPDATE "Error updating subscriber; subscriber not found." MKDSOE_SUBSCRIBER_DUPS_FOUND_UPDATE "Error updating subscriber; duplicate subscribers found." MKDSOE_SUBSCRIBER_DELETE_FAILED "Error deleting subscriber." MKDSOE_SUBSCRIBER_NOT_FOUND_DELETE "Error deleting subscriber; subscriber not found." MKDSOE_MULTIPLE_SUBSCRIBERS_DELETED "Deleting multiple subscribers." MKDSOE_SUBSCRIBER_DUPS_FOUND_DELETE "Error deleting subscriber; duplicate subscribers found." MKDSOE_SUBSCRIBER_DUMP_FAILED "Error dumping subscriber." MKDSOE_SUBSCRIBER_NOT_FOUND_DUMP "Error dumping subscriber; subscriber not found." MKDSOE_MULTIPLE_SUBSCRIBERS_DUMPED "Dumping duplicate subscribers." --*/ { PWCHAR *Argv; ULONG i, j; ULONG OptLen; DWORD Status = MKDSOE_SUCCESS; DWORD WStatus = ERROR_SUCCESS; PWCHAR NTFRSSettingsDn = NULL; PWCHAR ReplicaSetName = NULL; PWCHAR ReplicaSetType = NULL; PWCHAR FileFilter = NULL; PWCHAR DirectoryFilter = NULL; PWCHAR PrimaryMember = NULL; PBYTE pSchedule = NULL; DWORD Interval = 1; DWORD Stagger = 1; DWORD Offset = 0; DWORD Vbar; PWCHAR NT4ComputerName = NULL; PWCHAR ComputerDn = NULL; PWCHAR DomainName = NULL; PWCHAR MemberName = NULL; PWCHAR ServerRef = NULL; PWCHAR RootPath = NULL; PWCHAR StagePath = NULL; PWCHAR WorkingPath = NULL; PWCHAR RefDCName = NULL; PWCHAR *Values = NULL; PWCHAR Switch = NULL; PWCHAR pw; BOOL ClassFound = FALSE; DWORD Commands = 0; DS_NAME_RESULT *Cracked = NULL; HANDLE hDs = INVALID_HANDLE_VALUE; PLDAP_BERVAL *BerValues = NULL; GUID *Guid = NULL; PDOMAIN_CONTROLLER_INFO pDCInfo = NULL; BOOL bRetry = FALSE; DWORD DcFlags; PDSROLE_PRIMARY_DOMAIN_INFO_BASIC pBuffer = NULL; Argv = ConvertArgv(argc, argv); if (argc <= 1) { Usage(Argv); Status = MKDSOE_SUCCESS; goto ARG_CLEANUP; } for (i = 1; i < argc; ++i) { OptLen = wcslen(Argv[i]); _wcslwr(Argv[i]); Switch = Argv[i]; DPRINT1(" %20ws ", Switch); if ((*Switch != L'/') && (*Switch != L'-')) { Usage(Argv); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } ++Switch; // jump over - if (OptLen == 2 && ArgMatch(Switch, L"v")) { bVerboseMode=TRUE; DPRINT1(" %20ws ", Switch); } else if (OptLen == 3 && ArgMatch(Switch, L"vs")) { bVerboseModeSearch=TRUE; DPRINT1(" %20ws ", Switch); } else if (OptLen == 2 && ArgMatch(Switch, L"?")) { Usage(Argv); Status = MKDSOE_SUCCESS; goto ARG_CLEANUP; } else if (OptLen == 6 && ArgMatch(Switch, L"debug")) { bDebugMode = TRUE; bVerboseMode=TRUE; } else if (OptLen == 3 && (i+1 < argc) && ArgMatch(Switch, L"dc")) { i += 1; DcName = new WCHAR[wcslen(Argv[i])+1]; wcscpy(DcName, Argv[i]); DPRINT1("%ws", DcName); } else if (OptLen == 16 && (i+1 < argc) && ArgMatch(Switch, L"ntfrssettingsdn")) { i += 1; NTFRSSettingsDn = new WCHAR[wcslen(Argv[i])+1]; wcscpy(NTFRSSettingsDn, Argv[i]); DPRINT1("%ws", NTFRSSettingsDn); } else if (OptLen == 8 && (i+1 < argc) && ArgMatch(Switch, L"setname")) { i += 1; ReplicaSetName = new WCHAR[wcslen(Argv[i])+1]; wcscpy(ReplicaSetName, Argv[i]); DPRINT1("%ws", ReplicaSetName); } else if (OptLen == 11 && (i+1 < argc) && ArgMatch(Switch, L"computerdn")) { i += 1; ComputerDn = new WCHAR[wcslen(Argv[i])+1]; wcscpy(ComputerDn, Argv[i]); DPRINT1("%ws", ComputerDn); } else if (OptLen == 13 && (i+1 < argc) && ArgMatch(Switch, L"computername")) { i += 1; NT4ComputerName = new WCHAR[wcslen(Argv[i])+1]; wcscpy(NT4ComputerName, Argv[i]); DPRINT1("%ws", NT4ComputerName); } else if (OptLen == 11 && (i+1 < argc) && ArgMatch(Switch, L"membername")) { i += 1; MemberName = new WCHAR[wcslen(Argv[i])+1]; wcscpy(MemberName, Argv[i]); DPRINT1("%ws", MemberName); } else if (OptLen == 11 && (i+1 < argc) && ArgMatch(Switch, L"membername")) { i += 1; MemberName = new WCHAR[wcslen(Argv[i])+1]; wcscpy(MemberName, Argv[i]); DPRINT1("%ws", MemberName); } else if (OptLen == 8 && (i+1 < argc) && ArgMatch(Switch, L"dfsname")) { i += 1; DFSName = new WCHAR[wcslen(Argv[i])+1]; wcscpy(DFSName, Argv[i]); DPRINT1("%ws", DFSName); bDFSNaming = TRUE; } else if (OptLen == 9 && (i+1 < argc) && ArgMatch(Switch, L"rootpath")) { i += 1; RootPath = new WCHAR[wcslen(Argv[i])+1]; wcscpy(RootPath, Argv[i]); DPRINT1("%ws", RootPath); } else if (OptLen == 10 && (i+1 < argc) && ArgMatch(Switch, L"stagepath")) { i += 1; StagePath = new WCHAR[wcslen(Argv[i])+1]; wcscpy(StagePath, Argv[i]); DPRINT1("%ws", StagePath); } else if (OptLen == 12 && (i+1 < argc) && ArgMatch(Switch, L"workingpath")) { i += 1; WorkingPath = new WCHAR[wcslen(Argv[i])+1]; wcscpy(WorkingPath, Argv[i]); DPRINT1("%ws", WorkingPath); } else if (OptLen == 10 && (i+1 < argc) && ArgMatch(Switch, L"refdcname")) { i += 1; RefDCName = new WCHAR[wcslen(Argv[i])+1]; wcscpy(RefDCName, Argv[i]); DPRINT1("%ws", RefDCName); } else if (OptLen == 10 && ArgMatch(Switch, L"createset")) { bCreateSet = TRUE; ++Commands; } else if (OptLen == 10 && ArgMatch(Switch, L"updateset")) { bUpdateSet = TRUE; ++Commands; } else if (OptLen == 7 && ArgMatch(Switch, L"delset")) { bDelSet = TRUE; ++Commands; } else if (OptLen == 13 && ArgMatch(Switch, L"createmember")) { bCreateMember = TRUE; ++Commands; } else if (OptLen == 13 && ArgMatch(Switch, L"updatemember")) { bUpdateMember = TRUE; ++Commands; } else if (OptLen == 10 && ArgMatch(Switch, L"delmember")) { bDelMember = TRUE; ++Commands; } else if (OptLen == 17 && ArgMatch(Switch, L"createsubscriber")) { bCreateSubscriber = TRUE; ++Commands; } else if (OptLen == 17 && ArgMatch(Switch, L"updatesubscriber")) { bUpdateSubscriber = TRUE; ++Commands; } else if (OptLen == 14 && ArgMatch(Switch, L"delsubscriber")) { bDelSubscriber = TRUE; ++Commands; } else if (OptLen == 5 && ArgMatch(Switch, L"dump")) { bDump = TRUE; ++Commands; } else if (OptLen == 4 && ArgMatch(Switch, L"all")) { bAffectAll = TRUE; } else if (OptLen == 8 && (i+1 < argc) && ArgMatch(Switch, L"settype")) { i += 1; ReplicaSetType = new WCHAR[wcslen(Argv[i])+1]; wcscpy(ReplicaSetType, Argv[i]); DPRINT1("%ws", ReplicaSetType); } else if (OptLen == 11 && (i+1 < argc) && ArgMatch(Switch, L"filefilter")) { i += 1; FileFilter = new WCHAR[wcslen(Argv[i])+1]; wcscpy(FileFilter, Argv[i]); DPRINT1("%ws", FileFilter); } else if (OptLen == 16 && (i+1 < argc) && ArgMatch(Switch, L"directoryfilter")) { i += 1; DirectoryFilter = new WCHAR[wcslen(Argv[i])+1]; wcscpy(DirectoryFilter, Argv[i]); DPRINT1("%ws", DirectoryFilter); } else if (OptLen == 14 && (i+1 < argc) && ArgMatch(Switch, L"primarymember")) { i += 1; PrimaryMember = new WCHAR[wcslen(Argv[i])+1]; wcscpy(PrimaryMember, Argv[i]); DPRINT1("%ws", PrimaryMember); } else if (OptLen == 14 && ArgMatch(Switch, L"makemeprimary")) { bMakeMePrimary = TRUE; } else if (OptLen == 9 && (i+3 < argc) && ArgMatch(Switch, L"schedule")) { 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) && ArgMatch(Switch, L"schedmask")) { SchedMask = ReadScheduleFile(Argv[i+1]); if (SchedMask == NULL) { FreeArgv(argc,Argv); return MKDSOE_BAD_ARG; } else { if (bVerboseMode) { printf(" schedmask:\n"); PrintScheduleGrid(SchedMask, 0x0F); } } i+=1; } else if ((OptLen == 14) && (i+1 < argc) && ArgMatch(Switch, L"schedoverride")) { SchedOverride = ReadScheduleFile(Argv[i+1]); if (SchedOverride == NULL) { FreeArgv(argc,Argv); return MKDSOE_BAD_ARG; } else { if (bVerboseMode) { printf(" schedoverride:\n"); PrintScheduleGrid(SchedOverride, 0x0F); } } i+=1; } else { Usage(Argv); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } DPRINT0("\n"); } // // Begin of verify command line parameters. // if (Commands != 1) { if ((Commands == 2) && bDelSubscriber &&bDelMember) { // // The only time two commands are allowed is when /delsubscriber // is used with /delmember // } else { DPRINT0("INVALID ARG: Specify one and only one command except /delmember /delsubscriber.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } } if (NTFRSSettingsDn == NULL) { DPRINT0("INVALID ARG: Missing parameter /ntfrssettingsdn.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } if ((ReplicaSetName == NULL) && !(bDump && bAffectAll)) { DPRINT0("INVALID ARG: Missing parameter /setname.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } if (bCreateSet && ReplicaSetType == NULL) { DPRINT0("INVALID ARG: Missing parameter /settype.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } if (bCreateMember) { if (MemberName == NULL) { DPRINT0("INVALID ARG: Missing parameter /membername.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } if (bDFSNaming) { if (DFSName == NULL) { DPRINT0("INVALID ARG: Missing parameter /dfsname.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } Vbar = wcscspn(DFSName, L"|"); if ((Vbar == wcslen(DFSName)) || (Vbar == 0) || ((wcslen(DFSName) - Vbar) < 2)) { // // No vertical bar found or root or junction parts are zero len. // DPRINT0("INVALID ARG: Member name must have v-bar with root and junction parts for DFS naming. /dfsname.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } } } if (bMakeMePrimary && (bCreateSet || bUpdateSet || bDelSet || bDelMember)) { DPRINT0("INVALID ARG: /makemeprimary not allowed with /createset, /updateset, /delset, or /delmember.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } if (bUpdateMember) { if ((MemberName == NULL) && (ComputerDn == NULL) && (NT4ComputerName == NULL)) { DPRINT0("INVALID ARG: Missing parameter /membername or /computerdn or /computername.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } } if (bCreateSubscriber) { if ((MemberName == NULL) && (ComputerDn == NULL) && (NT4ComputerName == NULL)) { DPRINT0("INVALID ARG: Missing parameter /membername or /computerdn or /computername.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } if (RootPath == NULL) { DPRINT0("INVALID ARG: Missing parameter /rootpath.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } if (StagePath == NULL) { DPRINT0("INVALID ARG: Missing parameter /stagepath.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } if (bDFSNaming) { if (DFSName == NULL) { DPRINT0("INVALID ARG: Missing parameter /dfsname.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } Vbar = wcscspn(DFSName, L"|"); if ((Vbar == wcslen(DFSName)) || (Vbar == 0) || ((wcslen(DFSName) - Vbar) < 2)) { // // No vertical bar found or root or junction parts are zero len. // DPRINT0("INVALID ARG: Member name must have v-bar with root and junction parts for DFS naming. /dfsname.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } } } if (bUpdateSubscriber) { if ((MemberName == NULL) && (ComputerDn == NULL) && (NT4ComputerName == NULL)) { DPRINT0("INVALID ARG: Missing parameter /membername or /computerdn or /computername.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } } if (bDelMember) { if (!bAffectAll && (MemberName == NULL) && (ComputerDn == NULL) && (NT4ComputerName == NULL)) { DPRINT0("INVALID ARG: Missing parameter /membername or /computerdn or /computername or /all.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } } if (bDelSubscriber) { if (!bDelMember && (MemberName == NULL) && (ComputerDn == NULL) && (NT4ComputerName == NULL)) { DPRINT0("INVALID ARG: Missing parameter /membername or /computerdn or /computername.\n"); Status = MKDSOE_BAD_ARG; goto ARG_CLEANUP; } } // // End of verify command line parameters. // Status = BindToDC(DcName, &pLdap); // // Verify that the ntfrs settings DN exists and is actually a NTFRSSettings object. // i=0; ClassFound = FALSE; Values = GetValues(pLdap, NTFRSSettingsDn, ATTR_CLASS, TRUE); while (Values && Values[i]) { if (_wcsicmp(Values[i],ATTR_NTFRS_SETTINGS) == 0) { ClassFound = TRUE; break; } ++i; } LDAP_FREE_VALUES(Values); if (!ClassFound) { DPRINT0("INVALID ARG: Check parameter /ntfrssettingsdn.\n"); Status = MKDSOE_NO_NTFRS_SETTINGS; goto CLEANUP; } // // Verify that the computer DN exists and is actually a computer object. // if (ComputerDn != NULL) { i=0; ClassFound = FALSE; Values = GetValues(pLdap, ComputerDn, ATTR_CLASS, TRUE); while (Values && Values[i]) { if ((_wcsicmp(Values[i],ATTR_COMPUTER)== 0) || (_wcsicmp(Values[i],ATTR_USER) == 0)) { ClassFound = TRUE; break; } ++i; } LDAP_FREE_VALUES(Values); if (!ClassFound) { DPRINT0("INVALID ARG: Check parameter /computerdn.\n"); Status = MKDSOE_BAD_ARG; goto CLEANUP; } } if (bCreateSet) { if (bSchedule) { BuildSchedule(&pSchedule, Interval, Stagger, Offset); Status = CreateNewReplicaSet(NTFRSSettingsDn,ReplicaSetName, ReplicaSetType, FileFilter, DirectoryFilter, PrimaryMember, pSchedule); } else { Status = CreateNewReplicaSet(NTFRSSettingsDn,ReplicaSetName, ReplicaSetType, FileFilter, DirectoryFilter, PrimaryMember, NULL); } } if (bUpdateSet) { if (bSchedule) { BuildSchedule(&pSchedule, Interval, Stagger, Offset); Status = UpdateReplicaSet(NTFRSSettingsDn,ReplicaSetName, ReplicaSetType, FileFilter, DirectoryFilter, PrimaryMember, pSchedule); } else { Status = UpdateReplicaSet(NTFRSSettingsDn,ReplicaSetName, ReplicaSetType, FileFilter, DirectoryFilter, PrimaryMember, NULL); } } if (bCreateMember || bUpdateMember || bCreateSubscriber || bUpdateSubscriber || bDelSubscriber || bDelMember) { // // Get the Coumputer Dn using the NT4 account name. // if ((ComputerDn == NULL) && (NT4ComputerName != NULL)) { if (hDs == INVALID_HANDLE_VALUE) { WStatus = DsBind(DcName, NULL, &hDs); if (WStatus != ERROR_SUCCESS) { DPRINT2("ERROR: Can not bind to DC (%ws) %d\n", DcName, WStatus); Status = MKDSOE_BAD_ARG; goto CLEANUP; } } WStatus = DsCrackNames(hDs, // in hDS, DS_NAME_NO_FLAGS, // in flags, DS_NT4_ACCOUNT_NAME, // in formatOffered, DS_FQDN_1779_NAME, // in formatDesired, 1, // in cNames, &NT4ComputerName, // in *rpNames, &Cracked); // out *ppResult if ((WStatus == ERROR_SUCCESS) && Cracked && Cracked->cItems && Cracked->rItems && (Cracked->rItems->status == DS_NAME_NO_ERROR)) { ComputerDn = FrsWcsDup(Cracked->rItems->pName); DsFreeNameResult(Cracked); } else { DPRINT1("ERROR: Can not crack computerDn %d\n", WStatus); Status = MKDSOE_BAD_ARG; goto CLEANUP; } } // bugbug ("we need the domain guid for the DFSRoot's Domain NC which may not be the same as the member") // Get the domain GUID for the domain containing the member. // if ((ComputerDn != NULL) && bCreateSubscriber) { if (hDs == INVALID_HANDLE_VALUE) { WStatus = DsBind(DcName, NULL, &hDs); if (WStatus != ERROR_SUCCESS) { DPRINT2("ERROR: Can not bind to DC (%ws) %d\n", DcName, WStatus); Status = MKDSOE_BAD_ARG; goto CLEANUP; } } // // First get the DS_CANONICAL_NAME. // eg: engineering.widget.com/software/spencer katt // Domain-only version includes trailing '/'. // WStatus = DsCrackNames(hDs, // in hDS, DS_NAME_NO_FLAGS, // in flags, DS_FQDN_1779_NAME, // in formatOffered, DS_CANONICAL_NAME, // in formatDesired, 1, // in cNames, &ComputerDn, // in *rpNames, &Cracked); // out *ppResult if ((WStatus == ERROR_SUCCESS) && Cracked && Cracked->cItems && Cracked->rItems && (Cracked->rItems->status == DS_NAME_NO_ERROR)) { // // Get the Canonical name and terminate the string after the domain name. // DomainName = FrsWcsDup(Cracked->rItems->pName); DPRINT1("Canonical name: %ws\n", DomainName); pw = DomainName; while (*pw && (*pw != L'\\')) { pw++; } if (pw != DomainName) { *pw = L'\0'; } DPRINT1("Domain name: %ws\n", DomainName); DsFreeNameResult(Cracked); } else { DPRINT2("ERROR: Can not crack canonical name (%ws) %d\n", ComputerDn, WStatus); Status = MKDSOE_BAD_ARG; goto CLEANUP; } // // Take the domain name and get the domain GUID. // WStatus = DsCrackNames(hDs, // in hDS, DS_NAME_NO_FLAGS, // in flags, DS_CANONICAL_NAME, // in formatOffered, DS_UNIQUE_ID_NAME, // in formatDesired, 1, // in cNames, &DomainName, // in *rpNames, &Cracked); // out *ppResult if ((WStatus == ERROR_SUCCESS) && Cracked && Cracked->cItems && Cracked->rItems && (Cracked->rItems->status == DS_NAME_NO_ERROR)) { DomainGuidStr = FrsWcsDup(Cracked->rItems->pName); DPRINT1("Canonical name: %ws\n", DomainGuidStr); DsFreeNameResult(Cracked); } else { DPRINT2("ERROR: Can not crack canonical DomainName (%ws) %d\n", DomainName, WStatus); Status = MKDSOE_BAD_ARG; goto CLEANUP; } #if 0 // Alternate sequence if above fails. DcFlags = DS_DIRECTORY_SERVICE_PREFERRED; do { // // Get a DC name for a DC in the domain containing this member. // WStatus = DsGetDcName(NULL, DomainName, NULL, NULL, DcFlags, &pDCInfo); if (WStatus != ERROR_SUCCESS) { DPRINT1("ERROR: Can not get computer name of DC in member's domain. (%ws)\n", DomainName); Status = MKDSOE_BAD_ARG; NetApiBufferFree(pDCInfo); goto CLEANUP; } if ( !(pDCInfo->Flags & DS_DS_FLAG) ) { // down level domain DPRINT1("ERROR: ComputerDn in down level domains not supported. (%ws)\n", DomainName); Status = MKDSOE_BAD_ARG; NetApiBufferFree(pDCInfo); goto CLEANUP; } // // Get the domain guid. // WStatus = DsRoleGetPrimaryDomainInformation(pDCInfo->DomainControllerName, DsRolePrimaryDomainInfoBasic, (PBYTE *)&pBuffer); if ((WStatus == RPC_S_SERVER_UNAVAILABLE) && !bRetry) { bRetry = TRUE; // only retry once NetApiBufferFree(pDCInfo); DcFlags |= DS_FORCE_REDISCOVERY; } else { break; } } while (1); if (WStatus == ERROR_SUCCESS) { Guid = &pBuffer->DomainGuid; // // Build stringized Guid in the format returned by the DS. // It has an extra dash. // e.g. DsCrackNames(hDs,DS_NAME_NO_FLAGS, DS_NT4_ACCOUNT_NAME, // DS_UNIQUE_ID_NAME, 1, &NT4ComputerName, &Cracked); // swprintf(DomainGuidStr, L"{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", Guid->Data1, Guid->Data2, Guid->Data3, Guid->Data4[0], Guid->Data4[1], Guid->Data4[2], Guid->Data4[3], Guid->Data4[4], Guid->Data4[5], Guid->Data4[6], Guid->Data4[7]); Guid = NULL; DsRoleFreeMemory(pBuffer); NetApiBufferFree(pDCInfo); } else { DPRINT1("ERROR: Failed to get domain GUID for computer (%ws)\n", ComputerDn); Status = MKDSOE_BAD_ARG; NetApiBufferFree(pDCInfo); goto CLEANUP; } } #endif if (hDs != INVALID_HANDLE_VALUE) { DsUnBind(&hDs); } // // Go get the Guid of the computer object and convert to stringized form // that the FRS GUI Snapin will recognize. // BerValues = GetBerValues(pLdap, ComputerDn, ATTR_OBJECT_GUID, TRUE); if (BerValues && BerValues[0]) { // Copy the first value (if any) Guid = (GUID *)BerValues[0]->bv_val; } if (Guid != NULL) { // // Build stringized Guid in the format returned by the DS. // It has an extra dash. // e.g. DsCrackNames(hDs,DS_NAME_NO_FLAGS, DS_NT4_ACCOUNT_NAME, // DS_UNIQUE_ID_NAME, 1, &NT4ComputerName, &Cracked); // swprintf(ComputerObjectGuidStr, L"{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", Guid->Data1, Guid->Data2, Guid->Data3, Guid->Data4[0], Guid->Data4[1], Guid->Data4[2], Guid->Data4[3], Guid->Data4[4], Guid->Data4[5], Guid->Data4[6], Guid->Data4[7]); Guid = NULL; } else { DPRINT1("INVALID ARG: Cannot get Object Guid for computerdn (%ws).\n", ComputerDn); Status = MKDSOE_MEMBER_OBJ_CRE_FAILED; goto CLEANUP; } // Free ldap's array of BerValues LDAP_FREE_BER_VALUES(BerValues); // // Check if MemberName is "ComputerObjectGuid". If so then use the // stringized Guid to make the FRS UI (in the DFS UI) happy. // Else use the MemberName itself. // if (ArgMatch(MemberName, L"ComputerObjectGuid")) { FREE(MemberName); MemberName = new WCHAR[wcslen(ComputerObjectGuidStr)+1]; wcscpy(MemberName, ComputerObjectGuidStr); DPRINT1("Member name conversion to GUID: %ws\n", MemberName); bDFSNaming = TRUE; } if (bCreateMember) { Status = CreateNewReplicaMember(NTFRSSettingsDn, ReplicaSetName, MemberName, ComputerDn, ServerRef, RefDCName); } if (bUpdateMember) { Status = UpdateReplicaMember(NTFRSSettingsDn, ReplicaSetName, MemberName, ComputerDn, ServerRef, RefDCName); } if (bDelMember) { Status = DeleteReplicaMember(NTFRSSettingsDn, ReplicaSetName, MemberName,ComputerDn); } if (bCreateSubscriber || bUpdateSubscriber) { Status = CreateNewSubscriber(NTFRSSettingsDn, ReplicaSetName, MemberName, ComputerDn, RootPath, StagePath, WorkingPath, RefDCName); } if (bDelSubscriber && !bDelMember) { Status = DeleteSubscriber(NTFRSSettingsDn, ReplicaSetName, MemberName, ComputerDn); } } if (bDelSet) { Status = DeleteReplicaSet(NTFRSSettingsDn, ReplicaSetName); } if (bDump ) { DumpReplicaSet(NTFRSSettingsDn, ReplicaSetName); } goto CLEANUP; CLEANUP: ldap_unbind(pLdap); ARG_CLEANUP: FreeArgv(argc,Argv); FREE(MemberName); FREE(ReplicaSetName); FREE(ComputerDn); FREE(NT4ComputerName); return Status; }