cmdtools.cpp

命令行方式的硬盘工具 可以在dos和nt下运行。 需要djgpp和vs7.0以上

    //    istringstream strin(argv);
    //    strin.setf(ios_base::hex,ios_base::basefield);
    //    strin>>ulPos;
    //    if( !strin.fail() )
    //     {
    //        argv++;
    //        while(!isspace(*argv)&&*argv)
    //            argv++;
    //        if(!(*argv))
    //            return ;
    //        argv++;
    //        if(m_pSrch->Init((BYTE*)m_ppBuf[m_uBufPos],argv,m_BufSize[m_uBufPos]))
    //        {
    //            ulFindPos=m_pSrch->CSearch::Find(ulPos);
    //        }
    //        else
    //        {
    //            m_pError->AddError(ERR_SEARCH_INIT_FAIL);
    //            return;
    //        }
    //    }
    //    else
    //        return;
    //}
    //else
    //{
    //    ulFindPos=m_pSrch->CSearch::FindNext();
    //}
    //if(ulFindPos!=c_dwSRCH_NO_FOUND)
    //{
    //    m_pError->AddError(ERR_NO_ERROR);
    //    cout<< setw(8) << ulFindPos <<endl;
    //}
    //else
    //    m_pError->AddError(ERR_SRCH_NO_FIND);
}


void CTools::SearchSectors(CHAR *argv)
{
    BOOL bFind=FALSE;
    DWORD64 ulPos;
    if(*argv)
    {
        istringstream strin(argv);
        strin.setf(ios_base::hex,ios_base::basefield);
        strin>>ulPos;
        if( !strin.fail() )
         {
            argv++;
            while(!isspace(*argv)&&*argv)
                argv++;
            if(!(*argv))
                return ;
            argv++;
            if(m_pSrch->Init((BYTE*)m_ppBuf[c_CMD_T_MAX_BUF-1],argv,m_BufSize[c_CMD_T_MAX_BUF-1] -c_CMD_T_BUFF_SIZE_ADJ))
            {
                bFind=m_pSrch->Find(ulPos);
            }
            else
            {
                m_pError->AddError(ERR_SEARCH_INIT_FAIL);
                return;
            }
        }
        else
            return;
    }
    else
    {
        bFind=m_pSrch->FindNext();
    }
    if(bFind ==0 )
		m_pError->AddError("Please Find First.");
	if (bFind == 1 )
        m_pError->AddError(ERR_NO_ERROR);
	if (bFind == 2 )
        m_pError->AddError(ERR_SRCH_NO_FIND);
}

void CTools::SearchSectorsOffset(CHAR *argv)
{
	BOOL bFind=FALSE;
	DWORD64 ulPos;
	unsigned int uNSectors,uOffset;

	istringstream strin(argv);
	strin.setf(ios_base::hex,ios_base::basefield);
	strin>>ulPos>>uNSectors>>uOffset;
	char buf[_MAX_PATH];
	strin.getline(buf, _MAX_PATH-1);
	if( strin.fail())
	{
		return;
	}
	else
	{
		if(m_pSrch->Init((BYTE*)m_ppBuf[c_CMD_T_MAX_BUF-1], buf,m_BufSize[c_CMD_T_MAX_BUF-1]-c_CMD_T_BUFF_SIZE_ADJ))
		{
			bFind=m_pSrch->FindAtOffset(ulPos,uNSectors,uOffset, TRUE);
		}
		else
		{
			m_pError->AddError(ERR_SEARCH_INIT_FAIL);
			return;
		}
	}
	if(bFind)
		m_pError->AddError(ERR_NO_ERROR);
	else
		m_pError->AddError(ERR_SRCH_NO_FIND);  
}

void CTools::SearchSectorsAll(CHAR *argv)
{
    SearchSectors(argv);
    if(m_pError->GetLastError()!=ERR_NO_ERROR)
        return;
    while(m_pError->GetLastError()!=ERR_NO_ERROR)
    {
        *argv='\0';
        SearchSectors(argv);
    }
}

void CTools::AddSub(CHAR *argv)
{
    DWORD64 tmp[2];
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>tmp[0]>>tmp[1];
    if(strin.fail())
        return ;
    if(tmp[1]!=0)
    {
        cout<< tmp[0]<< '+' << tmp[1] << '=' << (tmp[0]+tmp[1]) << endl
            << tmp[0]<< '-' << tmp[1] << '=' << (tmp[0]-tmp[1]) << endl
            << tmp[0]<< '*' << tmp[1] << '=' << (tmp[0]*tmp[1]) << endl
            << tmp[0]<< '/' << tmp[1] << '=' << (tmp[0]/tmp[1]) << endl
            << tmp[0]<< '%' << tmp[1] << '=' << (tmp[0]%tmp[1]) << endl ;
            m_pError->AddError(ERR_NO_ERROR);
    }
}

void CTools::LoadNtfsBootBlock(CHAR *argv)
{
    DWORD64 ulStartSec;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulStartSec;
    if( strin.fail())
         ulStartSec=m_dqBufSector[m_uBufPos];

    if(m_pNtfs->LoadBootBlock(ulStartSec))
	{
		cout<< m_pNtfs->BootBToString();
		m_pError->AddError(ERR_NO_ERROR);
	}
}

void CTools::LoadBpb(CHAR *argv)
{
    DWORD64 ulStartSec;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulStartSec;
    if( strin.fail())
         ulStartSec=m_dqBufSector[m_uBufPos];

    if(m_pLD32->LoadBoot(ulStartSec))
	{
		m_pLD32->CaculateData();
		cout<< m_pLD32->Boot32ToString();
		m_pError->AddError(ERR_NO_ERROR);
	}
}

void CTools::LoadCluster(CHAR *argv)
{
    DWORD64 ulStartSec;
    DWORD ulLen;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulStartSec>>ulLen;
    if( strin.fail())
        return ;
    m_pLD32->LoadFat32(ulStartSec,ulLen);
    m_pError->AddError(ERR_NO_ERROR);
	m_bIsLoadFat = TRUE;
}

void CTools::LoadDir32(CHAR *argv)
{
    DWORD bufOffset;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>bufOffset;
    if( strin.fail())
         bufOffset=0;
	if(bufOffset>m_BufSize[m_uBufPos])
		bufOffset=0;

    m_pLD32->LoadFdt(&m_ppBuf[m_uBufPos][bufOffset]);
    m_pError->AddError(ERR_NO_ERROR);
    //m_pLD32->m_iDirLen=m_BufSize[m_uBufPos];
}

void CTools::LoadPartition(CHAR *argv)
{
    DWORD64 dqPosition;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>dqPosition;
    if( strin.fail())
         dqPosition=m_dqBufSector[m_uBufPos];
    if(m_pLD32->LoadPartition(dqPosition))
	{
		cout<< m_pLD32->PartitionToString();
		m_pError->AddError(ERR_NO_ERROR);
	}
 }

void CTools::LoadMbr(CHAR *argv)
{
    DWORD64 ulStartSec;
    DWORD tmp=0;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulStartSec>>tmp;
    if( strin.fail())
    {
        ulStartSec=m_dqBufSector[m_uBufPos];
        tmp=0;
    }

    if(tmp>=4)
    {
        m_pError->AddError(ERR_MBR_SIZE);
        return;
    }
    if(m_pLD32->LoadMbr(ulStartSec,tmp))
	{
		cout<< m_pLD32->MbrToString();
		m_pError->AddError(ERR_NO_ERROR);
	}
}

void CTools::LoadSectors(CHAR *argv)
{
    DWORD64 ulStartSec;
    DWORD ulLen;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulStartSec>>ulLen;
    if( strin.fail())
        return ;
    if(ulLen*c_uBYTES_PER_SECTOR>m_BufSize[m_uBufPos])
    {
        m_pError->AddError(ERR_BUF_SMALL);
        return;
    }
    if(m_pInt13->ReadSector(ulStartSec,ulLen,(BYTE *)m_ppBuf[m_uBufPos]) )
        m_pError->AddError(ERR_NO_ERROR);
/*    else
        m_pError->AddError();
*/
}

void CTools::LoadFile(CHAR *argv)
{
	string sname;
	DWORD len;
	istringstream strin(argv);
	strin.setf(ios_base::hex,ios_base::basefield);
	strin>>sname;
	if( strin.fail())
		return;
	strin>>len;
	if( strin.fail())
		len=m_BufSize[m_uBufPos];
    if(ReadFile(sname.c_str(),len,m_ppBuf[m_uBufPos]))
		m_pError->AddError(ERR_NO_ERROR);
}


void CTools::DispDir(CHAR *argv)
{
    unsigned int ulPos;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulPos;
    if( strin.fail()  )
    {
		ulPos=0;
    }
    cout<< m_pLD32->DirToString(m_ppBuf[m_uBufPos],m_BufSize[m_uBufPos],ulPos);
    m_pError->AddError(ERR_NO_ERROR);
}

void CTools::DispBuffer(CHAR *argv)
{
    m_pError->AddError(ERR_NO_ERROR);
    unsigned int ulPos=0;
    unsigned int j=0;
    unsigned int k=0;
    cout<< noshowbase;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulPos;
    if( !strin.fail() )
    {  
      if(ulPos<m_BufSize[m_uBufPos])
        {
            m_ulBufOffset=ulPos;
        }
    }
    if(m_ulBufOffset>=m_BufSize[m_uBufPos])
    {
        m_ulBufOffset=0;
    }
    for(;j<c_CMD_T_MAX_LINES;j++)
    {
        unsigned int tmp;
        cout<< setw(6) << (m_ulBufOffset+j*c_CMD_T_MAX_COL);
        for(k=0;k<c_CMD_T_MAX_COL;k++)
        {
            tmp=m_ulBufOffset+j*c_CMD_T_MAX_COL+k;
            if(tmp>=m_BufSize[m_uBufPos])
            {
                cout<<  showbase << endl;
                m_pError->AddError(ERR_NO_ERROR);
                return ;
            }
            cout<< ' ' << setw(2) << (unsigned short) (m_ppBuf[m_uBufPos][tmp]);
        }
        cout<<"   ";
        UCHAR c;
        for(k=0;k<c_CMD_T_MAX_COL;k++)
        {
            c=m_ppBuf[m_uBufPos][m_ulBufOffset+j*c_CMD_T_MAX_COL+k];
            if(iscntrl(c)||c==0xff)
			{
				cout<< '.';
			}
			//if( ( c>=0x00 &&c <= 0x1F) || 0x7F==c)
                
            else
                cout<< (unsigned char)c;
        }
        cout<< endl;
    }
    cout<<  showbase ;
    m_ulBufOffset+=c_CMD_T_MAX_LINES*c_CMD_T_MAX_COL;
    m_pError->AddError(ERR_NO_ERROR);
}

void CTools::BufferAlloc(CHAR *argv)
{
    unsigned int BufNum;
    unsigned int BufSize;
    BYTE  *tmp;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>BufNum>>BufSize;
    if( strin.fail())
        return ;
     if(BufNum>c_CMD_T_MAX_BUF)
        return ;
    tmp=new BYTE [(BufSize*c_COMMON_KB*sizeof(BYTE))];
    if(tmp==NULL)
    {
        m_pError->AddError(ERR_NO_MEMORY);
        return;
    }
    memset(tmp,0,(BufSize*c_COMMON_KB*sizeof(BYTE)));
    delete [] m_ppBuf[BufNum];
    m_ppBuf[BufNum]=tmp;
    m_BufSize[BufNum]=BufSize*c_COMMON_KB;
    m_pError->AddError(ERR_NO_ERROR);
}

void CTools::Init(void)
{
    int i=0;
	m_bIsLoadFat = FALSE;
    for(;i<c_CMD_T_MAX_BUF-1;i++)
    {
        m_ppBuf[i]=new BYTE[(c_CMD_T_INIT_BUF_SIZE*c_COMMON_KB*sizeof(BYTE))];
        if(m_ppBuf[i]==NULL)
        {
            m_pError->AddError(ERR_NO_MEMORY);
            break ;
        }
        memset(m_ppBuf[i],0,(c_CMD_T_INIT_BUF_SIZE*c_COMMON_KB*sizeof(BYTE)) );
        m_BufSize[i]=c_CMD_T_INIT_BUF_SIZE*c_COMMON_KB;
    }
    m_ppBuf[c_CMD_T_MAX_BUF-1]=new BYTE [(c_CMD_T_SEARCH_BUF_SIZE*c_COMMON_KB*sizeof(BYTE))];
    if(m_ppBuf[c_CMD_T_MAX_BUF-1]==NULL)
    {
        m_pError->AddError(ERR_NO_MEMORY);
    }
    else
    {
        memset(m_ppBuf[c_CMD_T_MAX_BUF-1],0,(c_CMD_T_SEARCH_BUF_SIZE*c_COMMON_KB*sizeof(BYTE)) );
        m_BufSize[c_CMD_T_MAX_BUF-1]=c_CMD_T_SEARCH_BUF_SIZE*c_COMMON_KB;
    }
    m_pszFileName=new CHAR[(_MAX_PATH*sizeof(CHAR))];
    memset(m_pszFileName,0,(_MAX_PATH*sizeof(CHAR)) );
    m_pLD32=new CLogicalDisk32(m_pInt13,m_pError);
	m_pNtfs=new CNtfs(m_pInt13,m_pError);
    m_pSrch=new CSectorSrch(m_pError,0x80);
    if(m_pInt13==NULL
        ||m_pszFileName==NULL
        ||m_pLD32==NULL
        ||m_pSrch==NULL
        )
    {
        m_pError->AddError(ERR_NO_MEMORY);
        Quit();
        return ;
    }
//    m_pError->AddError(ERR_NO_ERROR);
    *m_pszFileName='\0';
}

BOOL CTools::WriteFile(const CHAR *szFileName,unsigned int FileLength,BYTE  *Buffer)
{
    ofstream ofn;
    ofn.open(szFileName,ios_base::binary|ios_base::trunc);
    if(ofn)
    {
        ofn.seekp(0,ios_base::beg);
        ofn.write((char*)Buffer,FileLength);
        cout<< "WriteBytes(Dec)= " << dec <<  FileLength << hex << endl;
        if(ofn.bad())
        {
            m_pError->AddError(ERR_FILE_WRITE);
			return FALSE;
        }
		return TRUE;
    }
    else
    {
        m_pError->AddError(ERR_FILE_OPEN);
		return FALSE;
	}
}

BOOL CTools::ReadFile(const CHAR *szFileName,unsigned int ulLen,BYTE  * Buffer)
{
    ifstream in;
    in.open(szFileName,ios_base::binary);
    if(in)
    {
        in.seekg(0,ios_base::beg);
        in.read((char*)Buffer,ulLen);
        streamsize readsize=in.gcount();
        in.seekg(0,ios_base::end);
       // ifstream::pos_type filesize=in.tellg();
        cout<< "ReadBytes(Dec)= " << dec << readsize << hex <<endl; //" \tFileSize(Dec)= "<< dec << filesize << hex << endl;
        if(in.bad())
        {
            m_pError->AddError(ERR_FILE_READ);
			return FALSE;
        }
		return TRUE; 
    }
    else
    {
        m_pError->AddError(ERR_FILE_OPEN);
		return FALSE;
	}
}

void CTools::EditBuffer(CHAR *argv)
{
    unsigned int ulPos;
    unsigned short c;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulPos;
    if( strin.fail())
        return ;
    if(ulPos>m_BufSize[m_uBufPos])
        return ;
    string s1(argv);
    string::size_type pos=s1.find("\"");
    if(pos!=string::npos)
    {
        string s3=s1.substr(pos+1);
		string::size_type len=s3.length();
		if( (ulPos+len ) >m_BufSize[m_uBufPos])
            return ;
        memcpy(&m_ppBuf[m_uBufPos][ulPos],s3.c_str(),len);
    }
    else
    {
 //       argv++;
        int i=0;
       // istringstream strin2(s1);
        strin.setf(ios_base::hex,ios_base::basefield);     
		strin>>setw(2)>>c;
        while( !strin.fail() )
		{
            if( (ulPos+i)>=m_BufSize[m_uBufPos])
                return ;
            m_ppBuf[m_uBufPos][ulPos+i]=c;
			i++;
			strin>>setw(2)>>c;
        }
        if(i<=0)
            return ;
    }
    m_pError->AddError(ERR_NO_ERROR);
}

void CTools::Calculater(CHAR *argv)
{
    CHAR c;
    int tmp = 0;
	string s;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>c>>s;