C / C++ / MFC

// SieveOfErathostenes.cpp : main project file.

#include <bitset>
#include <iostream>
#include <ctime>

using namespace System;
using namespace std;

int main(array<System::String ^> ^args)
{
    const int N = 2000000;
    clock_t cstart = clock();

    std::bitset<N + 1> b;
    int count = 0;
    int i;
    for (i = 2; i <= N; i++)
        b.set(i);
    i = 2;

    while (i * i <= N)
    {
        if (b.test(i))
        {
            count++;
            int k = 2 * i;
            while (k <= N)
            {
                b.reset(k);
                k += i;
            }
        }
        i++;
    }

    while (i <= N)
    {
        if (b.test(i))  count++;
        i++;
    }

    clock_t cend = clock();
    double millis = 1000.0 * (cend - cstart) / CLOCKS_PER_SEC;

    cout << count << " primes \n" << millis << " milliseconds\n";

    return 0;
}

Sieve.h
#pragma once
#include <iostream>

int main(array<System::String ^> ^args);

jon_80 wrote:

C1010 - unexpected eof. Says it needs a header file, but I "forgot" what to include. Afiak the header file includes:

sawerr wrote:

We know that, WinMain is buried in the MFC Framework. OK but how can Windows call it?

sawerr wrote:

If i import a dll and although i do not use one of the imported function in that dll, OS can still call that function? Or OS can only call imported dll functions which are used by exe?? If the function doesn't import by exe, it is never be called?

krish_kumar wrote:

So how to proceed ....??

krish_kumar wrote:

I use it in user mode.

krish_kumar wrote:

I took a sample file and get it's corrresponding cluster
details using "FSCTL_GET_RETRIEVAL_POINTERS" along with DeviceIoControl and copied it into another partition.
And this successfully copied the source file .
Like this I wanna get all files.So it may take much more time..?

krish_kumar wrote:

How to get all file one by one.?

krish_kumar wrote:

And I tried one more way using "FSCTL_GET_VOLUME_BITMAP"along with DeviceIoControl.In this case I take the
whole volume as handle to createfile() and find out the used cluster only;and simply copied them to another partition.

#include "WinIoCtl.h"
#include "stdio.h"
#include "ntddvol.h"
#include "stdafx.h"
#include "Cluster_Used_Logical_to_Phy_Ofst.h" 


 

#ifdef _DEBUG
#define new DEBUG_NEW
#endif
 

 

CWinApp theApp;
using namespace std;

 

   
   DWORD BytesReturned,dwBytesReturnedh; 
   LARGE_INTEGER li_add;
   int i=0;
   UINT32  *BitmapDetail;
   DWORD dwError;
   LPDWORD lpBytesReturned;
   int iCopy_Count=0;
   LONGLONG llCountUsed=0;
   LONGLONG llCountFree=0;
   LONGLONG llTotalCount=0; 

 

   
   LONGLONG llChunk_Size=512; // chunk size
   LONGLONG Rest_Size=llVolume_Size;
   LONGLONG dwclusterSizeInBytes=512;
 

   LPVOID bBuffer1 = VirtualAlloc(NULL,512,MEM_COMMIT,PAGE_READWRITE);    

    BOOL IsClusterUsed (UINT64 Cluster)
    {
return ((BitmapDetail[Cluster / 32] & (1<< (Cluster % 32))) ? TRUE : FALSE);     
    }

 

 

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])

{

      int nRetCode = 0; 

      if(!AfxWinInit(::GetModuleHandle(NULL), NULL,::GetCommandLine(), 0))

      {    

      _tprintf(_T("Fatal Error: MFC initialization failed\n"));

      nRetCode = 1;

      }

      else

      {         

 

        HANDLE h_MyDrive_Src,h_MyDrive_Dest,hDevice;   

        DWORD dwRetBytes1,dwRetBytes2;  

 

 
       //Disk handle
       hDevice = CreateFile( _T("\\\\.\\PhysicalDrive0"),

                          GENERIC_READ | GENERIC_WRITE,

                          FILE_SHARE_READ | FILE_SHARE_WRITE,

                          NULL, OPEN_EXISTING,

                          FILE_ATTRIBUTE_NORMAL, NULL); 

       if (hDevice==INVALID_HANDLE_VALUE)
       {
       printf("\nUnable to Open the Device: Error Number is : %d\n",GetLastError());      
       }
 



 

     //Source partition  Drive handle...to get bitmap volume
        h_MyDrive_Src = CreateFile( L"\\\\.\\H:",
                                  GENERIC_READ|GENERIC_WRITE,
                                  FILE_SHARE_READ | FILE_SHARE_WRITE,
                                  NULL,
                                  OPEN_EXISTING,
                            FILE_ATTRIBUTE_NORMAL|FILE_FLAG_NO_BUFFERING, 
                                   NULL);                                
                                  

      if (h_MyDrive_Src==INVALID_HANDLE_VALUE)
      {
      printf("\nUnable to Open  Device: Error No: %d\n",GetLastError());  
      }      

      
   //Destination partition --  

   h_MyDrive_Dest=CreateFile( L"\\\\.\\I:",
                            GENERIC_WRITE,					                    FILE_SHARE_READ|FILE_SHARE_WRITE,
			    NULL,
			    OPEN_EXISTING,				                    FILE_ATTRIBUTE_NORMAL|FILE_FLAG_NO_BUFFERING,
			     NULL);

   if (h_MyDrive_Dest==INVALID_HANDLE_VALUE)
   {
   printf("\nUnable to Open  Device: Error Number:%d\n",GetLastError());
   }
       



   //Getting the  Bitmap of source Volume

    STARTING_LCN_INPUT_BUFFER StartingLCN;
    VOLUME_BITMAP_BUFFER *Bitmap = NULL;
    UINT32 BitmapSize;
    DWORD BytesReturned1;
    BOOL Result;
    ULONGLONG ClusterCount  = 0;

 

 

    StartingLCN.StartingLcn.QuadPart = 0;   
    BitmapSize = sizeof (VOLUME_BITMAP_BUFFER) + 4;
    Bitmap = (VOLUME_BITMAP_BUFFER *) malloc (BitmapSize); 

    Result = DeviceIoControl(h_MyDrive_Src,
		                 FSCTL_GET_VOLUME_BITMAP,
				     &StartingLCN,
				     sizeof (StartingLCN),
				     Bitmap,
				     BitmapSize,
				     &BytesReturned1,
				     NULL);

    if (Result == FALSE &&GetLastError()!= ERROR_MORE_DATA)
    {
    free (Bitmap);
    goto label12;
    }

                      

    ClusterCount = Bitmap->BitmapSize.QuadPart -
                   Bitmap->StartingLcn.QuadPart;  //TOT noof clusters

    cout<<"\n Tot no of clusters :"<<ClusterCount<<"\n";
    BitmapSize = sizeof (VOLUME_BITMAP_BUFFER) + (Bitmap->;BitmapSize.QuadPart / 8) + 1;

    Bitmap = (VOLUME_BITMAP_BUFFER *) realloc (Bitmap, BitmapSize);

 

    Result = DeviceIoControl(h_MyDrive_Src,
		                 FSCTL_GET_VOLUME_BITMAP,
				     &StartingLCN,
				     sizeof (StartingLCN),
				     Bitmap,
				     BitmapSize,
				     &BytesReturned,
				     NULL);   

    DWORD LastError = GetLastError ();

    if (Result == FALSE)

    {

    printf ("\nCouldn't properly read volume bitmap\n");

    free (Bitmap);

    goto label12;

    }

    BitmapDetail = (UINT32 *) malloc (sizeof(UINT32) * (1 + (ClusterCount / 32)));

    memcpy (BitmapDetail, Bitmap->Buffer, sizeof(UINT32) * (1 + (ClusterCount / 32)));

 

 

       UINT64 Max;

       UINT64 cc;

       Max=ClusterCount;

       UINT64 usedcluster=0; 

       LONGLONG llReturnValue = 0;
   
  /*    
  BOOL lbb = DeviceIoControl (h_MyDrive_Dest,FSCTL_LOCK_VOLUME,NULL,NULL,NULL,NULL,&BytesReturned,NULL);

		if(!lbb)
		{
		printf("Lock Volume Failed %d \n",GetLastError());
		}
  */
 

 

    for (cc = 0; cc< Max; cc++)

    {
 /*
if(!ReadFile(h_MyDrive_Src,bBuffer1,llChunk_Size,&dwRetBytes1,0))
{
printf("\nUnable to Read the DriveError:%d\n",GetLastError));             

}
*/       

    

            if ( IsClusterUsed (cc)) // return 1 from buffer

            {   

             llCountUsed++;
             printf("\n used %I64d",llCountUsed);
             llTotalCount++;   

 

//----conversion starts here  ( Logical offset to Physical)

            

            LARGE_INTEGER li_Lcn;
            li_Lcn.QuadPart=(LONGLONG)cc;
            VOLUME_LOGICAL_OFFSET logicalOffset;
            logicalOffset.LogicalOffset= li_Lcn.QuadPart *dwclusterSizeInBytes;

 

            VOLUME_PHYSICAL_OFFSETS physicalOffsets;
            DWORD dw_Bytes_Returned;

 

            if (!DeviceIoControl(h_MyDrive_Src,

                                 IOCTL_VOLUME_LOGICAL_TO_PHYSICAL,

                                 &logicalOffset,

                                 sizeof(VOLUME_LOGICAL_OFFSET),

                                 &physicalOffsets,

                                 sizeof(VOLUME_PHYSICAL_OFFSETS),

                                 &dw_Bytes_Returned,

                                  NULL) )

 

   {
    printf("\n Error occoured :%d",GetLastError)); 
    goto label12;
   }

                  

   llReturnValue += physicalOffsets.PhysicalOffset [0].Offset;
   printf("\n physical offsets = %I64d",llReturnValue); 




 // Let's start to read &  write data
     
if(!SetFilePointer(hDevice,llReturnValue,NULL,0))  //hDevice :disk handle
{
printf("\nSetFilePointer Failed: Error Number : %d\n",GetLastError());
}

                  

if(!ReadFile(hDevice,bBuffer1,llChunk_Size,&dwRetBytes1,0))//hDevice :disk handle
{
printf("\nUnable to Read  ( src _ handle disk) the Drive Error: %d\n",GetLastError());          
}

 
 

if(!WriteFile(h_MyDrive_Dest,bBuffer1,llChunk_Size,&dwRetBytes2,0))/*to desti volume handle  */

{

printf("\nUnable towrite the Drive Error:%d\n",GetLastError());           

}
                                    
}
else
{   llCountFree++;
    llTotalCount++;
     // printf("\n free %I64d",llCountFree);

}
}

 

 

cout<<"\n Total no of clusters :"<<llTotalCount<<"\n";   
cout<<"\n Used no of clusters :"<<llCountUsed<<"\n";
cout<<"\n Free no of clusters :"<<llCountFree<<"\n";

 
 

/*
 BOOL lbbb = DeviceIoControl(h_MyDrive_Dest,FSCTL_UNLOCK_VOLUME,NULL,NULL,NULL,NULL,&BytesReturned,NULL);

if(!lbbb)
{
printf("Lock Volume Failed %d \n",GetLastError());
}
*/

                  

 

CloseHandle(h_MyDrive_Src); //close source

CloseHandle(h_MyDrive_Dest);

 

BOOL bupdate= DeviceIoControl(hDevice,
		              IOCTL_DISK_UPDATE_PROPERTIES,
				 NULL,
				 NULL,
				 NULL,
				 NULL,				
                                 &dwBytesReturnedh,
				 NULL);

       CloseHandle(hDevice); 

label12:

       cout<<"\n Press any key to continue...........\n\n";
       char c=getchar();
      }

      return nRetCode;

}