windows-xp/Source/XPSP1/NT/admin/dsutils/displayspecifierupgrade/analisys.cpp

#include "headers.hxx"
#include "global.hpp"


#include "Analisys.hpp"
#include "AnalisysResults.hpp"
#include "CSVDSReader.hpp"
#include "resource.h"
#include "AdsiHelpers.hpp"
#include "constants.hpp"
#include "dspecup.hpp"




Analisys::Analisys
   (
      const CSVDSReader&   csvReader409_,
      const CSVDSReader&   csvReaderIntl_,
      const String&        ldapPrefix_,
      const String&        rootContainerDn_,
      AnalisysResults      &res,
      const String         &reportName_,//=L"", 
      void                 *caleeStruct_,//=NULL,
		progressFunction     stepIt_,//=NULL,
		progressFunction     totalSteps_//=NULL,
   )
   :
   csvReader409(csvReader409_),
   csvReaderIntl(csvReaderIntl_),
   ldapPrefix(ldapPrefix_),
   rootContainerDn(rootContainerDn_),
   results(res),
   reportName(reportName_),
   caleeStruct(caleeStruct_),
   stepIt(stepIt_),
   totalSteps(totalSteps_)
{
   LOG_CTOR(Analisys);
   ASSERT(!ldapPrefix.empty());
   ASSERT(!rootContainerDn.empty());

};


// Analisys entry point
HRESULT 
Analisys::run()
{
   LOG_FUNCTION(Analisys::run);

   setReplaceW2KStrs();

   HRESULT hr=S_OK;
   do
   {
      LongList locales;
      for(long t=0;LOCALEIDS[t]!=0;t++)
      {
         locales.push_back(LOCALEIDS[t]);
      }
      locales.push_back(LOCALE409[0]);
      
      if(totalSteps!=NULL)
      {
         // The cast bellow is for IA64 compilation since we know
         // that locales.size() will fit in a long.
         totalSteps(static_cast<long>(locales.size()),caleeStruct);
      }

      BREAK_ON_FAILED_HRESULT(hr);

      LongList::iterator begin=locales.begin();
      LongList::iterator end=locales.end();


      while(begin!=end)
      {
         long locale=*begin;
         bool isPresent;

         hr=dealWithContainer(locale,isPresent);
         BREAK_ON_FAILED_HRESULT(hr);

         if (isPresent)
         {
            hr=dealWithXPObjects(locale);
            BREAK_ON_FAILED_HRESULT(hr);

            hr=dealWithW2KObjects(locale);
            BREAK_ON_FAILED_HRESULT(hr);
         }

         if(stepIt!=NULL)
         {
            stepIt(1,caleeStruct);
         }

         begin++;
      }
      BREAK_ON_FAILED_HRESULT(hr);

      if(!reportName.empty())
      {
         hr=createReport(reportName);
         BREAK_ON_FAILED_HRESULT(hr);
      }
   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}

// add entry to result.createContainers if container is not present
// also returns flag isPresent
HRESULT 
Analisys::dealWithContainer(
   const long  locale,
   bool        &isPresent)
{
   LOG_FUNCTION(Analisys::dealWithContainer);

   ASSERT(locale > 0); 
   ASSERT(!rootContainerDn.empty());
   
     

   HRESULT hr = S_OK;
   

   do
   {
      String container = String::format(L"CN=%1!3x!,", locale);
      String childContainerDn =ldapPrefix +  container + rootContainerDn;

      // Attempt to bind to the container.
         
      SmartInterface<IADs> iads(0);
      hr = AdsiOpenObject<IADs>(childContainerDn, iads);
      if (HRESULT_CODE(hr) == ERROR_DS_NO_SUCH_OBJECT)
      {
         // The container object does not exist.  This is possible because
         // the user has manually removed the container, or because it
         // was never created due to an aboted post-dcpromo import of the
         // display specifiers when the forest root dc was first promoted.

         results.createContainers.push_back(locale);

         isPresent=false;

         hr = S_OK;
         break;
      }  
      else if (FAILED(hr))
      {
         error=String::format(IDS_ERROR_BINDING_TO_CONTAINER,
                              childContainerDn.c_str());
         break;
      }


      // At this point, the bind succeeded, so the child container exists.
      // So now we want to examine objects in that container.

      isPresent=true;
   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}

// add entries to results.conflictingXPObjects or
// results.createXPObject as necessary
HRESULT 
Analisys::dealWithXPObjects(const long locale)
{
   LOG_FUNCTION(Analisys::dealWithXPObjects);

   ASSERT(locale > 0);
   ASSERT(!rootContainerDn.empty());

   HRESULT hr = S_OK;

   do
   {
      for (
               int i = 0;
               *NEW_XP_OBJECTS[i]!=0;
               ++i
          )
      {
         String objectName = NEW_XP_OBJECTS[i];
         
         String objectPath =
            ldapPrefix +  L"CN=" + objectName + L"," + 
            String::format(L"CN=%1!3x!,", locale) + rootContainerDn;

         SmartInterface<IADs> iads(0);
         hr = AdsiOpenObject<IADs>(objectPath, iads);
         if (HRESULT_CODE(hr) == ERROR_DS_NO_SUCH_OBJECT)
         {
            // The object does not exist. This is what we expect. We want
            // to add the object in the repair phase.
            ObjectId tempObj(locale,objectName);
            results.createXPObjects.push_back(tempObj);
            hr = S_OK;
            continue;
         }
         else if (SUCCEEDED(hr))
         {
            // The object already exists. We have a conflict.
            ObjectId tempObj(locale,objectName);
            results.conflictingXPObjects.push_back(tempObj);
          }
         else
         {

            error=String::format(
                  IDS_ERROR_BINDING_TO_OBJECT,
                  objectName.c_str(),
                  objectPath.c_str());
 
            break;
         }
      }
      BREAK_ON_FAILED_HRESULT(hr);
   }
   while (0);
   
   LOG_HRESULT(hr);
   return hr;

}



// add entries to results.createW2KObjects 
//       and results.objectActions as necessary
HRESULT 
Analisys::dealWithW2KObjects(const long locale)
{
   LOG_FUNCTION(Analisys::dealWithW2KObjects);
   ASSERT(locale  >0);
   ASSERT(!rootContainerDn.empty());

   HRESULT hr = S_OK;

   do
   {
      for(
            long i = 0;
            *(CHANGE_LIST[i].object)!=0;
            ++i
         )
      {
         String objectName = CHANGE_LIST[i].object;
         String objectPath =
            ldapPrefix +  L"CN=" + objectName + L"," + 
            String::format(L"CN=%1!3x!,", locale) + rootContainerDn;

         SmartInterface<IADs> iads(0);
         hr = AdsiOpenObject<IADs>(objectPath, iads);
         if (HRESULT_CODE(hr) == ERROR_DS_NO_SUCH_OBJECT)
         {
            // The object does not exist. 
            ObjectId tempObj(locale,objectName);
            results.createW2KObjects.push_back(tempObj);
            hr = S_OK;
            continue;
         }
         else if (SUCCEEDED(hr))
         {
            // At this point, the display specifier object exists.  Determine if
            // if has been touched since its creation.

            SmartInterface<IDirectoryObject> iDirObj;
            
            hr=iDirObj.AcquireViaQueryInterface(iads); 
           // hr = iads->QueryInterface(IID_IDirectoryObject,(void **)iDirObj);
            BREAK_ON_FAILED_HRESULT(hr);
       
            hr = checkChanges(locale,CHANGE_LIST[i],iDirObj);
            BREAK_ON_FAILED_HRESULT(hr);

         }
         else
         {
            error=String::format(
                  IDS_ERROR_BINDING_TO_OBJECT,
                  objectName.c_str(),
                  objectPath.c_str());

            break;
         }
      }
      BREAK_ON_FAILED_HRESULT(hr);
   }
   while (0);
   
   LOG_HRESULT(hr);
   return hr;

}

HRESULT 
Analisys::checkChanges(
   const long locale,
   const sChangeList& changes,
   IDirectoryObject *iDirObj)
{
   LOG_FUNCTION(Analisys::checkChanges);

   wchar_t *object=changes.object;
   HRESULT hr=S_OK;
   for(
      long i = 0;
      *(changes.changes[i].property)!=0;
      ++i)
   {
         struct sChange change=changes.changes[i];
         switch(change.type)
         {
         case ADD_ALL_CSV_VALUES: 
            
            hr = addAllCsvValues
                 (
                     iDirObj,
                     locale,
                     object,
                     change.property
                 );

            if(FAILED(hr))
            {
               LOG_HRESULT(hr);
               return hr;
            }
            break;

         case ADD_VALUE: 
       
            hr = addValue
                 (
                     iDirObj,
                     locale,
                     object,
                     change.property,
                     change.value
                 );
            
            if(FAILED(hr))
            {
               LOG_HRESULT(hr);
               return hr;
            }
            break;

         case REPLACE_W2K_MULTIPLE_VALUE: 

            hr = replaceW2KMultipleValue
                 (
                     iDirObj,
                     locale,
                     object,
                     change.property,
                     change.value
                 );

            if(FAILED(hr))
            {
               LOG_HRESULT(hr);
               return hr;
            }
            break;

         case REPLACE_W2K_SINGLE_VALUE: 

            hr = replaceW2KSingleValue
                 (
                     iDirObj,
                     locale,
                     object,
                     change.property,
                     change.value
                 );

            if(FAILED(hr))
            {
               LOG_HRESULT(hr);
               return hr;
            }
            break;

         case ADD_GUID: 

            hr = addGuid
                 (
                     iDirObj,
                     locale,
                     object,
                     change.property,
                     change.value
                 );

            if(FAILED(hr))
            {
               LOG_HRESULT(hr);
               return hr;
            }
            break;

         case REMOVE_GUID: 

            hr = removeGuid
                 (
                     iDirObj,
                     locale,
                     object,
                     change.property,
                     change.value
                 );

            if(FAILED(hr))
            {
               LOG_HRESULT(hr);
               return hr;
            }
            break;

         default:
            ASSERT(false);
         }
   }
   
   LOG_HRESULT(S_OK);
   return S_OK;
}


// adds ordAndGuid to the property if Guid is not already there.
HRESULT 
Analisys::addGuid(
   IDirectoryObject     *iDirObj,
   const int            locale,
   const wchar_t        *object, 
   const wchar_t        *property, 
   const wchar_t        *ordAndGuid)
{
   LOG_FUNCTION(Analisys::addGuid);

   HRESULT hr = S_OK;

   String propertStr(property);
   String ordAndGuidStr(ordAndGuid);
   
   do
   {
      String guidFound;
      hr=getADGuid(   
                     iDirObj,
                     propertStr,
                     ordAndGuidStr,
                     guidFound
                  );

      BREAK_ON_FAILED_HRESULT(hr);
   
      if (hr == S_FALSE)
      {
         ObjectId tempObj(locale,String(object));
      
         ValueActions &act=results.objectActions[tempObj][property];
         act.addValues.push_back(ordAndGuidStr);
      }
       
   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}

// adds all csv values still not on the property
HRESULT
Analisys::addAllCsvValues(
   IDirectoryObject     *iDirObj,
   const long           locale,
   const wchar_t        *object, 
   const wchar_t        *property)
{
   LOG_FUNCTION(Analisys::addAllCsvValues);
   
   HRESULT hr = S_OK;
   const CSVDSReader &csvReader=(locale==0x409)?csvReader409:csvReaderIntl;

   do
   {
      StringList values;
      hr=csvReader.getCsvValues(locale,object,property,values);
      BREAK_ON_FAILED_HRESULT(hr);

      if (values.size()==0)
      {
         error=String::format(IDS_NO_CSV_VALUE,locale,object);
         hr=E_FAIL;
         break;
      }
      StringList::iterator begin=values.begin();
      StringList::iterator end=values.end();
      while(begin!=end)
      {
         hr=addValue(iDirObj,locale,object,property,begin->c_str());
         BREAK_ON_FAILED_HRESULT(hr);
         begin++;
      }
      BREAK_ON_FAILED_HRESULT(hr);
   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}


// adds value to the property if it is not already there. 
HRESULT 
Analisys::addValue(
   IDirectoryObject     *iDirObj,
   const int            locale,
   const wchar_t        *object, 
   const wchar_t        *property,
   const wchar_t        *value)
{
   LOG_FUNCTION(Analisys::addValue);

   HRESULT hr = S_OK;

   String valueStr(value);
   String propertyStr(property);
   
   do
   {
      hr=isADValuePresent (   
                              iDirObj,
                              propertyStr,
                              valueStr
                          );

      BREAK_ON_FAILED_HRESULT(hr);
   
      if (hr == S_FALSE)
      {
         ObjectId tempObj(locale,String(object));
      
         ValueActions &act=results.objectActions[tempObj][property];
         act.addValues.push_back(value);
      }
       
   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}



//Auxiliary function for replaceW2KSingleValue
// retrieves csvValue
HRESULT 
Analisys::getCsvSingleValue
          (
            const int               locale,
            const wchar_t           *object, 
            const wchar_t           *property,
            String                  &csvValue
          )
{
   LOG_FUNCTION(Analisys::getCsvReplacementValue);

   const CSVDSReader &csvReader=(locale==0x409)?csvReader409:csvReaderIntl;

  
   HRESULT hr = S_OK;
   do
   {

      StringList XPCsvValues;
      hr=csvReader.getCsvValues(locale,object,property,XPCsvValues);
      BREAK_ON_FAILED_HRESULT(hr);

      // we should have only one value in the csv
      // since we can't distinguish the 
      // value we want to replace from others as
      // in REPLACE_W2K_MULTIPLE_VALE
      if(XPCsvValues.size() != 1)
      {
         error=String::format
                       (
                           IDS_NOT_ONE_CSV_VALUE,
                           XPCsvValues.size(),
                           csvReader.getFileName().c_str(),
                           locale,
                           object,
                           property
                       );
         hr=E_FAIL;
         break;
      }

      csvValue = *XPCsvValues.begin();

   } while(0);

   LOG_HRESULT(hr);
   return hr;
}


// The idea of replaceW2KValue is replacing the W2K value
// for the Whistler. We also make sure we don't extraneous values.
HRESULT 
Analisys::replaceW2KSingleValue
          (
               IDirectoryObject        *iDirObj,
               const int               locale,
               const wchar_t           *object, 
               const wchar_t           *property,
               const wchar_t           *value
          )
{
   LOG_FUNCTION(Analisys::replaceW2KValue);

   long index = *value;
   String objectStr(object);
   String propertyStr(property);

   HRESULT hr = S_OK;
   do
   {
      String XPCsvValue;

      hr=getCsvSingleValue
         (
            locale,
            object, 
            property,
            XPCsvValue
         );

      BREAK_ON_FAILED_HRESULT(hr);


    // Retrieve W2KCsvValue from replaceW2KStrs
      pair<long,long> tmpIndxLoc;
      tmpIndxLoc.first=index;
      tmpIndxLoc.second=locale;
      String &W2KCsvValue=replaceW2KStrs[tmpIndxLoc];

      // There is nothing to do if the Whistler csv value
      // is the same as it was in W2K
      if (XPCsvValue.icompare(W2KCsvValue)==0)
      {
         break;
      }

      // Now we might have a replacement to do since the value
      // changed from W2K to Whistler
      
      hr=isADValuePresent(iDirObj,propertyStr,XPCsvValue);
      BREAK_ON_FAILED_HRESULT(hr);

      if(hr == S_OK) // The Whistler value is already there
      {
         // We will remove any other value than the Whistler
         hr=removeExtraneous(iDirObj,locale,objectStr,propertyStr,XPCsvValue);
         break;
      }

      // Now we know that the Whistler value is not present
      // and therefore we will add it if the W2K value is present

      hr=isADValuePresent(iDirObj,propertyStr,W2KCsvValue);
      BREAK_ON_FAILED_HRESULT(hr);

      if(hr == S_OK) // The W2K value is there.
      {
         ObjectId tempObj(locale,String(object));
      
         ValueActions &act=results.objectActions[tempObj][property];
         act.addValues.push_back(XPCsvValue);
         act.delValues.push_back(W2KCsvValue);

         // remove all but the W2K that we removed in the previous line
         hr=removeExtraneous(iDirObj,locale,objectStr,propertyStr,W2KCsvValue);
         break;
      }

      // Now we know that neither Whistler nor W2K values are present
      // If we have a value we will log that it is a custom value

      String ADValue;
      hr=getADFirstValue(iDirObj,propertyStr,ADValue);
      BREAK_ON_FAILED_HRESULT(hr);

      if(hr == S_OK) // We have a value
      {
         SingleValue tmpCustom(locale,objectStr,propertyStr,ADValue);
         results.customizedValues.push_back(tmpCustom);

         // We will remove any other value than the one we found
         hr=removeExtraneous(iDirObj,locale,objectStr,propertyStr,ADValue);
         break;
      }
      
      // Now we know that we don't have any values at all.
      ObjectId tempObj(locale,String(object));

      ValueActions &act=results.objectActions[tempObj][property];
      act.addValues.push_back(XPCsvValue);
   }
   while(0);

   LOG_HRESULT(hr);
   return hr;
}

//Auxiliary function for replaceW2KMultipleValue
// retrieves csvValue and XPStart
HRESULT 
Analisys::getCsvMultipleValue
          (
            const int               locale,
            const wchar_t           *object, 
            const wchar_t           *property,
            const wchar_t           *value,
            String                  &csvValue,
            String                  &XPstart
          )
{
   LOG_FUNCTION(Analisys::getCsvReplacementValue);

   const CSVDSReader &csvReader=(locale==0x409)?csvReader409:csvReaderIntl;

  
   HRESULT hr = S_OK;
   do
   {
      String sW2KXP(value+2); // +2 for index and semicollon
      StringList lW2KXP;
      size_t cnt=sW2KXP.tokenize(back_inserter(lW2KXP),L";");
      XPstart=lW2KXP.back();

      // We have the W2K and the XP start
      ASSERT(cnt==2);

      // Search the csv for the value starting with the XP string 
      hr=csvReader.getCsvValue(
                                 locale,
                                 object,
                                 property,
                                 XPstart.c_str(),
                                 csvValue
                              );

      BREAK_ON_FAILED_HRESULT(hr);

      // We should always find a csv value
      if(hr == S_FALSE)
      {
         error=String::format(
                                 IDS_VALUE_NOT_IN_CSV,
                                 XPstart.c_str(),
                                 locale,
                                 object,
                                 property,
                                 csvReader.getFileName().c_str()
                             );
         hr=E_FAIL;
         break;
      }
   } while(0);

   LOG_HRESULT(hr);
   return hr;
}



// The idea of replaceW2KValue is replacing the W2K value
// for the Whistler. We also make sure we don't extraneous values.
HRESULT 
Analisys::replaceW2KMultipleValue
          (
               IDirectoryObject        *iDirObj,
               const int               locale,
               const wchar_t           *object, 
               const wchar_t           *property,
               const wchar_t           *value
          )
{
   LOG_FUNCTION(Analisys::replaceW2KValue);

   long index = *value;
   String objectStr(object);
   String propertyStr(property);

   HRESULT hr = S_OK;
   do
   {
      String XPCsvValue,XPStart;

      // Get the Whistler csv value and the start of the Whistler value
      hr=getCsvMultipleValue
         (
            locale,
            object, 
            property,
            value,
            XPCsvValue,
            XPStart
         );

      BREAK_ON_FAILED_HRESULT(hr);

      // Retrieve W2KCsvValue from replaceW2KStrs
      pair<long,long> tmpIndxLoc;
      tmpIndxLoc.first=index;
      tmpIndxLoc.second=locale;
      String &W2KCsvValue=replaceW2KStrs[tmpIndxLoc];

      // There is nothing to do if the Whistler csv value
      // is the same as it was in W2K
      if (XPCsvValue.icompare(W2KCsvValue)==0)
      {
         break;
      }

      // Now we might have a replacement to do since the value
      // changed from W2K to Whistler

      // First we should get the beginning of the W2K string
      // for use in removeExtraneous calls
      size_t pos=W2KCsvValue.find(L',');
      String W2KStart;
      // We only need to assert since the W2KStrs tool would 
      // detect any REPLACE_W2K_MULTIPLE_VALUE without a comma
      ASSERT(pos != String::npos);
      W2KStart=W2KCsvValue.substr(0,pos+1);

      
            
      hr=isADValuePresent(iDirObj,propertyStr,XPCsvValue);
      BREAK_ON_FAILED_HRESULT(hr);

      if(hr == S_OK) // The Whistler value is already there
      {
         hr=removeExtraneous(
                              iDirObj,
                              locale,
                              objectStr,
                              propertyStr,
                              XPCsvValue,
                              XPStart,
                              W2KStart
                            );
         BREAK_ON_FAILED_HRESULT(hr);

         break;
      }

      // Now we know that the Whistler value is not present
      // and therefore we will add it if the W2K value is present

      hr=isADValuePresent(iDirObj,propertyStr,W2KCsvValue);
      BREAK_ON_FAILED_HRESULT(hr);

      if(hr == S_OK) // The W2K value is there.
      {
         ObjectId tempObj(locale,String(object));
      
         ValueActions &act=results.objectActions[tempObj][property];
         act.addValues.push_back(XPCsvValue);
         act.delValues.push_back(W2KCsvValue);

         // remove all but the W2K that we removed in the previous line
         hr=removeExtraneous(
                              iDirObj,
                              locale,
                              objectStr,
                              propertyStr,
                              W2KCsvValue,
                              XPStart,
                              W2KStart
                            );
         break;
      }

      // Now we know that neither Whistler nor W2K values are present
      // If we have a value starting like the W2K we will log that it 
      // is a custom value

        
      String ADValue;

      hr=isADStartValuePresent(iDirObj,propertyStr,W2KStart,ADValue);
      BREAK_ON_FAILED_HRESULT(hr);

      if(hr==S_OK) // Something starts like the W2K csv value
      {
         SingleValue tmpCustom(locale,objectStr,propertyStr,ADValue);
         results.customizedValues.push_back(tmpCustom);

         // We will keep only the first custom value
         hr=removeExtraneous(
                              iDirObj,
                              locale,
                              objectStr,
                              propertyStr,
                              ADValue,
                              XPStart,
                              W2KStart
                            );
         break;
      }
      

      // Now neither Whistler, W2K or W2KStart are present
      if ( XPStart.icompare(W2KStart) != 0 )
      {
         // We have to check the XPStart as well

         hr=isADStartValuePresent(iDirObj,propertyStr,XPStart,ADValue);
         BREAK_ON_FAILED_HRESULT(hr);

         if(hr == S_OK) // Something starts like the Whistler csv value
         {
            SingleValue tmpCustom(locale,objectStr,propertyStr,ADValue);
            results.customizedValues.push_back(tmpCustom);

            // We will keep only the first custom value
            hr=removeExtraneous(
                                 iDirObj,
                                 locale,
                                 objectStr,
                                 propertyStr,
                                 ADValue,
                                 XPStart,
                                 W2KStart
                               );
            break;
         }
      }

      // Now we know that there are no values starting like
      // the Whistler or W2K csv values so we have to add 
      // the Whistler value
      ObjectId tempObj(locale,String(object));

      ValueActions &act=results.objectActions[tempObj][property];
      act.addValues.push_back(XPCsvValue);
   }
   while(0);

   LOG_HRESULT(hr);
   return hr;
}



// removes ordAndGuid from the property if Guid is there. 
HRESULT 
Analisys::removeGuid(
   IDirectoryObject     *iDirObj,
   const int            locale,
   const wchar_t        *object, 
   const wchar_t        *property,
   const wchar_t        *ordAndGuid)
{

   LOG_FUNCTION(Analisys::removeGuid);

   HRESULT hr = S_OK;
   String propertStr(property);
   String ordAndGuidStr(ordAndGuid);
   
   do
   {
      String guidFound;
      hr=getADGuid(   
                     iDirObj,
                     propertStr,
                     ordAndGuidStr,
                     guidFound
                  );
      BREAK_ON_FAILED_HRESULT(hr);
   
      if (hr == S_OK)
      {
         ObjectId tempObj(locale,String(object));
      
         ValueActions &act=results.objectActions[tempObj][property];
         act.delValues.push_back(guidFound);
      }
       
   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}


//called from RwplaceW2KMultipleValue to remove all values
// starting with start1 or start2 other than keeper
HRESULT
Analisys::removeExtraneous
          (
               IDirectoryObject     *iDirObj,
               const int            locale,
               const String         &object, 
               const String         &property,
               const String         &keeper,
               const String         &start1,
               const String         &start2
          )
{
   LOG_FUNCTION(Analisys::removeExtraneous);

   DWORD   dwReturn;
   ADS_ATTR_INFO *pAttrInfo   =NULL;
   
   // GetObjectAttributes swears that pAttrName is an IN argument.
   // It should have used a LPCWSTR but now we have to pay the 
   // casting price
   LPWSTR pAttrName[] ={const_cast<LPWSTR>(property.c_str())};
   
   HRESULT hr = S_OK;

   do
   {
      hr = iDirObj->GetObjectAttributes( 
                                          pAttrName, 
                                          1, 
                                          &pAttrInfo, 
                                          &dwReturn 
                                        );

      BREAK_ON_FAILED_HRESULT(hr);

      if(pAttrInfo==NULL)
      {
         hr = S_FALSE;
         break;

      }

      for (
            long val=0; 
            val < pAttrInfo->dwNumValues;
            val++, pAttrInfo->pADsValues++
          )
      {
         wchar_t *valueAD = pAttrInfo->pADsValues->CaseIgnoreString;

         if (  _wcsicmp(valueAD,keeper.c_str())!=0 &&
               (
                  _wcsnicmp(valueAD,start1.c_str(),start1.size())==0 ||
                  _wcsnicmp(valueAD,start2.c_str(),start2.size())==0
               )
            )
         {
            String value=pAttrInfo->pADsValues->CaseIgnoreString;
            ObjectId tempObj(locale,String(object));

            ValueActions &act=results.extraneousValues[tempObj][property];
            act.delValues.push_back(value);
         }
      }
   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}

// called from RwplaceW2KSingleValue to remove all values
// other than keeper
HRESULT
Analisys::removeExtraneous
          (
               IDirectoryObject     *iDirObj,
               const int            locale,
               const String         &object, 
               const String         &property,
               const String         &keeper
          )
{
   LOG_FUNCTION(Analisys::removeExtraneous);

   DWORD   dwReturn;
   ADS_ATTR_INFO *pAttrInfo   =NULL;
   
   // GetObjectAttributes swears that pAttrName is an IN argument.
   // It should have used a LPCWSTR but now we have to pay the 
   // casting price
   LPWSTR pAttrName[] ={const_cast<LPWSTR>(property.c_str())};
   
   HRESULT hr = S_OK;

   do
   {
      hr = iDirObj->GetObjectAttributes( 
                                          pAttrName, 
                                          1, 
                                          &pAttrInfo, 
                                          &dwReturn 
                                        );

      BREAK_ON_FAILED_HRESULT(hr);

      if(pAttrInfo==NULL)
      {
         hr = S_FALSE;
         break;

      }

      for (
            long val=0; 
            val < pAttrInfo->dwNumValues;
            val++, pAttrInfo->pADsValues++
          )
      {
         wchar_t *valueAD = pAttrInfo->pADsValues->CaseIgnoreString;

         if (  _wcsicmp(valueAD,keeper.c_str())!=0 )
         {
            String value=pAttrInfo->pADsValues->CaseIgnoreString;
            ObjectId tempObj(locale,String(object));

            ValueActions &act=results.extraneousValues[tempObj][property];
            act.delValues.push_back(value);
         }
      }
   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}

// if any value exists in the AD with the same guid as guidValue
// it is returned in guidFound, otherwise S_FALSE is returned
HRESULT
Analisys::getADGuid
          (
               IDirectoryObject     *iDirObj,
               const String         &property,
               const String         &guidValue,
               String               &guidFound
          )
{
   LOG_FUNCTION(Analisys::getADGuid);
   
   DWORD   dwReturn;
   ADS_ATTR_INFO *pAttrInfo   =NULL;
   
   // GetObjectAttributes swears that pAttrName is an IN argument.
   // It should have used a LPCWSTR but now we have to pay the 
   // casting price
   LPWSTR pAttrName[] ={const_cast<LPWSTR>(property.c_str())};

   size_t pos=guidValue.find(L',');
   ASSERT(pos!=String::npos);

   String guid=guidValue.substr(pos+1);

   
   HRESULT hr = S_OK;

   do
   {
      hr = iDirObj->GetObjectAttributes( 
                                          pAttrName, 
                                          1, 
                                          &pAttrInfo, 
                                          &dwReturn 
                                        );

      BREAK_ON_FAILED_HRESULT(hr);

      // If there are no values we finish the search
      hr=S_FALSE;

      if(pAttrInfo==NULL)
      {
         break;
      }

      

      for (
            long val=0; 
            val < pAttrInfo->dwNumValues;
            val++, pAttrInfo->pADsValues++
          )
      {
         
         wchar_t *guidAD=wcschr(pAttrInfo->pADsValues->CaseIgnoreString,L',');
         if(guidAD != NULL)
         {
            guidAD++;

            if (_wcsicmp(guid.c_str(),guidAD)==0)
            {
               guidFound=pAttrInfo->pADsValues->CaseIgnoreString;
               hr=S_OK;
               break;
            }
         }
      }

   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}


// returns S_OK if value is present or S_FALSE otherwise
HRESULT
Analisys::isADValuePresent
          (
               IDirectoryObject     *iDirObj,
               const String         &property,
               const String         &value
          )
{
   LOG_FUNCTION(Analisys::isADValuePresent);
   
   DWORD   dwReturn;
   ADS_ATTR_INFO *pAttrInfo   =NULL;
   
   // GetObjectAttributes swears that pAttrName is an IN argument.
   // It should have used a LPCWSTR but now we have to pay the 
   // casting price
   LPWSTR pAttrName[] ={const_cast<LPWSTR>(property.c_str())};
   
   HRESULT hr = S_OK;

   do
   {
      hr = iDirObj->GetObjectAttributes( 
                                          pAttrName, 
                                          1, 
                                          &pAttrInfo, 
                                          &dwReturn 
                                        );

      BREAK_ON_FAILED_HRESULT(hr);

      
      hr=S_FALSE;

      // If there are no values we finish the search
      if(pAttrInfo==NULL)
      {
         break;
      }

      for (
            long val=0; 
            val < pAttrInfo->dwNumValues;
            val++, pAttrInfo->pADsValues++
          )
      {
         wchar_t *valueAD=pAttrInfo->pADsValues->CaseIgnoreString;
         if (_wcsicmp(value.c_str(),valueAD)==0)
         {
            hr=S_OK;
            break;
         }
      }

   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}


// retrieves the first value starting with valueStart 
// from the Active Directory
// If no value is found S_FALSE is returned.
HRESULT
Analisys::isADStartValuePresent
          (
               IDirectoryObject     *iDirObj,
               const String         &property,
               const String         &valueStart,
               String               &value
          )
{
   LOG_FUNCTION(Analisys::isADStartValuePresent);
   
   DWORD   dwReturn;
   ADS_ATTR_INFO *pAttrInfo   =NULL;
   
   // GetObjectAttributes swears that pAttrName is an IN argument.
   // It should have used a LPCWSTR but now we have to pay the 
   // casting price
   LPWSTR pAttrName[] ={const_cast<LPWSTR>(property.c_str())};
   
   HRESULT hr = S_OK;

   do
   {
      hr = iDirObj->GetObjectAttributes( 
                                          pAttrName, 
                                          1, 
                                          &pAttrInfo, 
                                          &dwReturn 
                                        );

      BREAK_ON_FAILED_HRESULT(hr);
      
      value.erase();

      hr = S_FALSE;

      // If there are no values we finish the search
      if(pAttrInfo==NULL)
      {
         break;

      }

      for (
            long val=0; 
            (val < pAttrInfo->dwNumValues);
            val++, pAttrInfo->pADsValues++
          )
      {
         wchar_t *valueAD=pAttrInfo->pADsValues->CaseIgnoreString;
         if (_wcsnicmp(valueStart.c_str(),valueAD,valueStart.size())==0)
         {
            value=pAttrInfo->pADsValues->CaseIgnoreString;
            hr=S_OK;
            break;
         }
      }


   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}

// retrieves the first value starting with valueStart 
// from the Active Directory
// If no value is found S_FALSE is returned.
HRESULT
Analisys::getADFirstValue
          (
               IDirectoryObject     *iDirObj,
               const String         &property,
               String               &value
          )
{
   LOG_FUNCTION(Analisys::getADFirstValue);
   
   DWORD   dwReturn;
   ADS_ATTR_INFO *pAttrInfo   =NULL;
   
   // GetObjectAttributes swears that pAttrName is an IN argument.
   // It should have used a LPCWSTR but now we have to pay the 
   // casting price
   LPWSTR pAttrName[] ={const_cast<LPWSTR>(property.c_str())};
   
   HRESULT hr = S_OK;

   do
   {
      hr = iDirObj->GetObjectAttributes( 
                                          pAttrName, 
                                          1, 
                                          &pAttrInfo, 
                                          &dwReturn 
                                        );

      BREAK_ON_FAILED_HRESULT(hr);

      // If there are no values we finish the search
      if(pAttrInfo==NULL)
      {
         hr = S_FALSE;
         break;
      }

      value=pAttrInfo->pADsValues->CaseIgnoreString;

   }
   while (0);

   LOG_HRESULT(hr);
   return hr;
}



// auxiliary in the createReport to 
// enumerate an ObjectIdList
HRESULT 
Analisys::reportObjects
          (
               HANDLE file,
               const ObjectIdList &list,
               const String &header
          )
{
   LOG_FUNCTION(Analisys::reportObjects);
   HRESULT hr=S_OK;

   do
   {
      if(list.size()==0) break;
      hr=FS::WriteLine(file,header);
      BREAK_ON_FAILED_HRESULT(hr);

      ObjectIdList::const_iterator begin,end;
      begin=list.begin();
      end=list.end();
      while(begin!=end)
      {

         hr=FS::WriteLine(
                              file,
                              String::format
                              (
                                 IDS_RPT_OBJECT_FORMAT,
                                 begin->object.c_str(),
                                 begin->locale
                              )  
                         );
         BREAK_ON_FAILED_HRESULT(hr);
         begin++;
      }
      BREAK_ON_FAILED_HRESULT(hr);
   }
   while(0);

   LOG_HRESULT(hr);
   return hr;
}

// auxiliary in the createReport to 
// enumerate a LongList
HRESULT 
Analisys::reportContainers
            (
               HANDLE file,
               const LongList &list,
               const String &header
            )
{
   LOG_FUNCTION(Analisys::reportContainers);
   HRESULT hr=S_OK;

   do
   {
      if(list.size()==0) break;
      hr=FS::WriteLine(file,header);
      BREAK_ON_FAILED_HRESULT(hr);

      LongList::const_iterator begin,end;
      begin=list.begin();
      end=list.end();
      while(begin!=end)
      {

         hr=FS::WriteLine(
                              file,
                              String::format
                              (
                                 IDS_RPT_CONTAINER_FORMAT,
                                 *begin
                              )  
                         );
         BREAK_ON_FAILED_HRESULT(hr);
         begin++;
      }
      BREAK_ON_FAILED_HRESULT(hr);
   }
   while(0);

   LOG_HRESULT(hr);
   return hr;
}

// auxiliary in the createReport to 
// enumerate a SingleValueList
HRESULT 
Analisys::reportValues
            (
               HANDLE file,
               const SingleValueList &list,
               const String &header
            )
{
   LOG_FUNCTION(Analisys::reportContainers);
   HRESULT hr=S_OK;

   do
   {
      if(list.size()==0) break;
      hr=FS::WriteLine(file,header);
      BREAK_ON_FAILED_HRESULT(hr);

      SingleValueList::const_iterator begin,end;
      begin=list.begin();
      end=list.end();
      while(begin!=end)
      {

         hr=FS::WriteLine(
                              file,
                              String::format
                              (
                                 IDS_RPT_VALUE_FORMAT,
                                 begin->value.c_str(),
                                 begin->locale,
                                 begin->object.c_str(),
                                 begin->property.c_str()
                              )  
                         );
         BREAK_ON_FAILED_HRESULT(hr);
         begin++;
      }
      BREAK_ON_FAILED_HRESULT(hr);
   }
   while(0);

   LOG_HRESULT(hr);
   return hr;
}


// auxiliary in the createReport to 
// enumerate ObjectActions
HRESULT 
Analisys::reportActions
            (
               HANDLE file,
               const ObjectActions &list,
               const String &header
            )
{
   LOG_FUNCTION(Analisys::reportActions);
   HRESULT hr=S_OK;

   do
   {
      if(list.size()==0) break;
      hr=FS::WriteLine(file,header);
      BREAK_ON_FAILED_HRESULT(hr);

      ObjectActions::const_iterator beginObj=list.begin();
      ObjectActions::const_iterator endObj=list.end();

      while(beginObj!=endObj) 
      {

         hr=FS::WriteLine
                (
                     file,
                     String::format
                     (
                        IDS_RPT_OBJECT_FORMAT,
                        beginObj->first.object.c_str(),
                        beginObj->first.locale
                     )  
                 );
         BREAK_ON_FAILED_HRESULT(hr);
         
    
         PropertyActions::iterator beginAct=beginObj->second.begin();
         PropertyActions::iterator endAct=beginObj->second.end();

         while(beginAct!=endAct)
         {

            StringList::iterator 
               beginDel = beginAct->second.delValues.begin();
            StringList::iterator 
               endDel = beginAct->second.delValues.end();
            while(beginDel!=endDel)
            {
               hr=FS::WriteLine
                      (
                           file,
                           String::format
                           (
                              IDS_RPT_DEL_VALUE_FORMAT,
                              beginAct->first.c_str(),
                              beginDel->c_str()
                           )  
                       );
               BREAK_ON_FAILED_HRESULT(hr);

               beginDel++;
            }
            BREAK_ON_FAILED_HRESULT(hr); // break on if internal while broke


            StringList::iterator 
               beginAdd = beginAct->second.addValues.begin();
            StringList::iterator 
               endAdd = beginAct->second.addValues.end();
            while(beginAdd!=endAdd)
            {
               hr=FS::WriteLine
                      (
                           file,
                           String::format
                           (
                              IDS_RPT_ADD_VALUE_FORMAT,
                              beginAct->first.c_str(),
                              beginAdd->c_str()
                           )  
                       );
               BREAK_ON_FAILED_HRESULT(hr);

               beginAdd++;
            }
            BREAK_ON_FAILED_HRESULT(hr); // break on if internal while broke

            beginAct++;
         } // while(beginAct!=endAct)
         BREAK_ON_FAILED_HRESULT(hr); // break on if internal while broke

         beginObj++;
      } // while(beginObj!=endObj)
      
      BREAK_ON_FAILED_HRESULT(hr);

   }
   while(0);

   LOG_HRESULT(hr);
   return hr;
}


// Create the report from the AnalisysResults
HRESULT
Analisys::createReport(const String& reportName)
{
   LOG_FUNCTION(Analisys::createReport);
   HRESULT hr=S_OK;
   do
   {
      
      HANDLE file;

      hr=FS::CreateFile(reportName,
                        file,
                        GENERIC_WRITE);
   
      if (FAILED(hr))
      {
         error=String::format(IDS_COULD_NOT_CREATE_FILE,reportName.c_str());
         break;
      }


      do
      {
         hr=FS::WriteLine(file,String::load(IDS_RPT_HEADER));
         BREAK_ON_FAILED_HRESULT(hr);


         hr=reportActions (
                              file,
                              results.extraneousValues,
                              String::load(IDS_RPT_EXTRANEOUS)
                          );
         BREAK_ON_FAILED_HRESULT(hr);



         hr=reportValues (
                              file,
                              results.customizedValues,
                              String::load(IDS_RPT_CUSTOMIZED)
                          );
         BREAK_ON_FAILED_HRESULT(hr);

         hr=reportObjects (
                              file,
                              results.conflictingXPObjects,
                              String::load(IDS_RPT_CONFLICTINGXP)
                          );
         BREAK_ON_FAILED_HRESULT(hr);

         hr=reportActions (
                              file,
                              results.objectActions,
                              String::load(IDS_RPT_ACTIONS)
                          );
         BREAK_ON_FAILED_HRESULT(hr);
         
         hr=reportObjects  (
                              file,
                              results.createW2KObjects,
                              String::load(IDS_RPT_CREATEW2K)
                           );
         BREAK_ON_FAILED_HRESULT(hr);

         hr=reportObjects  (
                              file,
                              results.createXPObjects,
                              String::load(IDS_RPT_CREATEXP)
                           );
         BREAK_ON_FAILED_HRESULT(hr);
         
         hr=reportContainers(
                              file,
                              results.createContainers,
                              String::load(IDS_RPT_CONTAINERS)
                            );
         BREAK_ON_FAILED_HRESULT(hr);

      } while(0);

      CloseHandle(file);
      BREAK_ON_FAILED_HRESULT(hr);

   } while(0);

   LOG_HRESULT(hr);
   return hr;
}