todototry

隐藏api的磁盘数据移动程序

#ifndef BITMAP_H
#define BITMAP_H

#define _WIN32_WINNT 0x600
#include "windows.h"
#include "winioctl.h"
#include
#include
using namespace std;

class BitMap
{
public:
    void getMapList(const VOLUME_BITMAP_BUFFER *pInBuff);
    void dispalyMapListOfFree() const;
    void showVecOfBit() const;
    const map & returnMaplist() const;
    const vector & returnBitVec() const;
private:
    map mapListOfFree;
    vector vecOfBit;
};

#endif

#include "bitmap.h"
#include
#include
#include

void BitMap::getMapList(const VOLUME_BITMAP_BUFFER *pInBuff)
{
    ULONGLONG count_size = 0;
    ULONGLONG size_clusterarray = (pInBuff -> BitmapSize.QuadPart + 7) / 8;
    while (count_size != size_clusterarray)
    {
       bitset<8> bit(*(pInBuff -> Buffer + count_size));
       for (int i = 0; i != 8; ++i)
       {
           vecOfBit.push_back(bit[i]);
       }
       count_size++;
    }
    if (vecOfBit.size() != pInBuff -> BitmapSize.QuadPart)
    {
       ULONGLONG popnum = vecOfBit.size() - pInBuff -> BitmapSize.QuadPart;
       for (ULONGLONG i = 0; i < popnum; ++i)
       {
           vecOfBit.pop_back();
       }
    }

    ULONGLONG add = 0;
    __w64 unsigned int/*ULONGLONG*/ size = 0;
    for (__w64 unsigned int/*ULONGLONG*/ i = 0; i < vecOfBit.size();)
    {
       size = 0;
       if (vecOfBit[i] == 0)
       {
           add = i;
           __w64 unsigned int/*ULONGLONG*/ idx = i;
           while ((idx < vecOfBit.size()) && !vecOfBit[idx]) //
           {
               size ++;
               idx++;
           }
           i += size;
           mapListOfFree.insert(make_pair(add, size));
       }
       else
       {
           i++;
           continue;
       }
    }
}

void BitMap::showVecOfBit() const
{
    fstream vecbit("bitmap.txt", ios_base::out);
    if (!vecbit) return;
    for (__w64 unsigned int/*ULONGLONG*/ i = 0; i < vecOfBit.size(); ++i)
    {
       if (i % 32 == 0)
       {
           vecbit << endl;
       }
       vecbit << (DWORD)vecOfBit[i] << " ";
    }
    vecbit.close();
}

void BitMap::dispalyMapListOfFree() const
{
    cout << "Free Space List " << endl;
    for (map::const_iterator cit = mapListOfFree.begin(); cit != mapListOfFree.end(); ++cit)
    {
       cout << "address: " << ULONG((*cit).first) << "/tsize: " << ULONG((*cit).second) << endl;
    }
}

const map& BitMap::returnMaplist() const
{
    return mapListOfFree;
}

const vector& BitMap::returnBitVec() const
{
    return vecOfBit;
}

#ifndef MOVFLE_H
#define NOVFLE_H

#include
#include
using namespace std;
#define _WIN32_WINNT 0x600
#include "windows.h"
#include "winioctl.h"
#include "ddk.h"

class MovFle
{
public:
    BOOL init(string str_fileFullPathName, MyNtFsControlFile ptr);
    BOOL analysis(ULONGLONG ull_usedClusters, DWORD &rerCod);
    BOOL move(HANDLE hVolum, map &rmapList, DWORD &rerCod); //pair free space
    void displayFileMapList() const;
    ~MovFle();
private:
    HANDLE m_hFle;
    map m_mapAnalysised; //file should move
    string m_strFileName;
    MyNtFsControlFile m_mptr;
};

#endif

#include "movfle.h"

#include
#include
#include
#include

BOOL MovFle::init(string str_fileFullPathName, MyNtFsControlFile ptr)
{
    m_strFileName = str_fileFullPathName;
    m_hFle = CreateFile(str_fileFullPathName.c_str(), GENERIC_READ/* | GENERIC_WRITE | FILE_READ_DATA | FILE_WRITE_DATA | FILE_APPEND_DATA| FILE_EXECUTE | FILE_READ_ATTRIBUTES*/,
                       FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
                       /*FILE_ATTRIBUTE_NORMAL*/FILE_FLAG_NO_BUFFERING, NULL);
    if (INVALID_HANDLE_VALUE == m_hFle)
    {
       //may be a directory name
       m_hFle = CreateFile (str_fileFullPathName.c_str(), GENERIC_READ | FILE_SHARE_WRITE,
                           FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
                           NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
       if (INVALID_HANDLE_VALUE != m_hFle)
       {
           m_mptr = ptr;
           return TRUE;
       }
       return FALSE;
    }

    m_mptr = ptr;
    return TRUE;
}

MovFle::~MovFle()
{
    if (INVALID_HANDLE_VALUE != m_hFle)
    {
       CloseHandle(m_hFle);
    }
}

BOOL MovFle::analysis(ULONGLONG ull_usedClusters, DWORD &rerCod)
{
    STARTING_VCN_INPUT_BUFFER inbuff;
    inbuff.StartingVcn.QuadPart = 0;
    RETRIEVAL_POINTERS_BUFFER outbuf;
    ULONGLONG ull_DealedVcn = 0;
    BOOL bIsOk;
    DWORD dwReturnBytes = 0;
    vector, ULONGLONG> > vecFileBlock;

    //<, size>
    do
    {
       bIsOk = DeviceIoControl(m_hFle, FSCTL_GET_RETRIEVAL_POINTERS, &inbuff,
           sizeof(STARTING_VCN_INPUT_BUFFER), &outbuf, sizeof(RETRIEVAL_POINTERS_BUFFER), &dwReturnBytes, NULL);
       rerCod = GetLastError();

       //for dealing directory
       if (outbuf.ExtentCount == 0)
           break;

       vecFileBlock.push_back(make_pair(make_pair(outbuf.StartingVcn.QuadPart, outbuf.Extents[0].Lcn.QuadPart), outbuf.Extents[0].NextVcn.QuadPart - outbuf.StartingVcn.QuadPart));
       inbuff.StartingVcn.QuadPart = outbuf.Extents[0].NextVcn.QuadPart;
    } while((!bIsOk) && (rerCod == ERROR_MORE_DATA));

    //analysis and make
    for (DWORD currentBlock = 0; currentBlock != vecFileBlock.size(); ++currentBlock)
    {
       if (vecFileBlock[currentBlock].first.second >= ull_usedClusters)
       {
           m_mapAnalysised.insert(make_pair(vecFileBlock[currentBlock].first.first, vecFileBlock[currentBlock].second));
       }
       else
       {
           if (vecFileBlock[currentBlock].first.second + vecFileBlock[currentBlock].second > ull_usedClusters)
           {
               m_mapAnalysised.insert(make_pair((vecFileBlock[currentBlock].first.first + (ull_usedClusters - vecFileBlock[currentBlock].first.second)),
                                               (vecFileBlock[currentBlock].first.second + vecFileBlock[currentBlock].second - ull_usedClusters)));
           }
       }
    }

    if (m_mapAnalysised.size() != 0)
    {
       displayFileMapList();
    }

    BOOL result = (m_mapAnalysised.size() == 0) ? FALSE : TRUE;
    return result;
}

void MovFle::displayFileMapList() const
{
    cout << m_strFileName << "-> maplist : " << endl;
    map::const_iterator cit = m_mapAnalysised.begin();
    for (; cit != m_mapAnalysised.end(); ++cit)
    {
       cout << "startVcn : " << cit -> first << " " << "size : " << cit -> second << endl;
    }
    cout << endl;
}

/*
BOOL MovFle::move(HANDLE hVolum, std::map &rmapList, DWORD &rerCod)
{
    MOVE_FILE_DATA mfd;
    mfd.FileHandle = m_hFle;
    BOOL bIsOk = TRUE;
    DWORD dwReturnBytes = 0;

    ULONGLONG ull_startVcnInBlock = 0;

    if (rmapList.empty())
    {
       return FALSE;
    }

    map::iterator ite = rmapList.begin();

    for (map::const_iterator cit = m_mapAnalysised.begin(); cit != m_mapAnalysised.end(); ++ cit)
    {
       //check rmaplist size
       if (rmapList.size() == 0)
       {
           return FALSE;
       }

       //deal each block
       ULONGLONG ull_vcnInBlock = cit -> second;
       ULONGLONG ull_dealedVcnInBlock = 0;
       ull_startVcnInBlock = cit -> first;

       while (ull_dealedVcnInBlock < ull_vcnInBlock)
       {
           //check rmapList size
           if (rmapList.size() == 0)
           {
               return FALSE;
           }

           ite = rmapList.begin();   //always points to the first item

           if (ull_vcnInBlock - ull_dealedVcnInBlock <= ite -> second)   //space is enough
           {
               if (ull_vcnInBlock - ull_dealedVcnInBlock == ite -> second)   //==
               {
                   mfd.ClusterCount = ite -> second;
                   mfd.StartingVcn.QuadPart = ull_startVcnInBlock + ull_dealedVcnInBlock;
                   mfd.StartingLcn.QuadPart = ite -> first;

                   //dbg
                   cout << "now mov clusters : " << endl;
                   cout << "ClusterCount : "<< mfd.ClusterCount << endl;
                   cout << "StartingVcn : "<< mfd.StartingVcn.QuadPart << endl;
                   cout << "StartingLcn : "<< mfd.StartingLcn.QuadPart << endl;

                   bIsOk = DeviceIoControl(m_hFle, FSCTL_MOVE_FILE, &mfd, sizeof(MOVE_FILE_DATA),
                                           NULL, 0, &dwReturnBytes, NULL);
                   if (!bIsOk)
                   {
                       rerCod = GetLastError();

                       //dbg
                       cout << "error : " << endl;
                       cout << "ClusterCount : "<< mfd.ClusterCount << endl;
                       cout << "StartingVcn : "<< mfd.StartingVcn.QuadPart << endl;
                       cout << "StartingLcn : "<< mfd.StartingLcn.QuadPart << endl;
                       cout << "errcod : " << rerCod << endl;

                       return FALSE;
                   }
                   else
                   {
                       rmapList.erase(ite);
                   }
               }
               else   //<
               {
                   mfd.ClusterCount = ull_vcnInBlock - ull_dealedVcnInBlock;
                   mfd.StartingVcn.QuadPart = ull_startVcnInBlock + ull_dealedVcnInBlock;
                   mfd.StartingLcn.QuadPart = ite -> first;

                   //dbg
                   cout << "now mov clusters : " << endl;;
                   cout << "ClusterCount : "<< mfd.ClusterCount << endl;
                   cout << "StartingVcn : "<< mfd.StartingVcn.QuadPart << endl;
                   cout << "StartingLcn : "<< mfd.StartingLcn.QuadPart << endl;

                   bIsOk = DeviceIoControl(m_hFle, FSCTL_MOVE_FILE, &mfd, sizeof(MOVE_FILE_DATA),
                       NULL, 0, &dwReturnBytes, NULL);
                   if (!bIsOk)
                   {
                       rerCod = GetLastError();

                       //dbg
                       cout << "error : " << endl;
                       cout << "ClusterCount : "<< mfd.ClusterCount << endl;
                       cout << "StartingVcn : "<< mfd.StartingVcn.QuadPart << endl;
                       cout << "StartingLcn : "<< mfd.StartingLcn.QuadPart << endl;
                       cout << "errcod : " << rerCod << endl;

                       return FALSE;
                   }
                   else
                   {
                       pair tmppar = *ite;
                       rmapList.erase(ite);
                       rmapList.insert(make_pair(tmppar.first + mfd.ClusterCount, tmppar.second - mfd.ClusterCount));
                   }
               }
           }
           else   //>   space is not enough
           {
               mfd.ClusterCount = ite -> second;
               mfd.StartingVcn.QuadPart = ull_startVcnInBlock + ull_dealedVcnInBlock;
               mfd.StartingLcn.QuadPart = ite -> first;

               bIsOk = DeviceIoControl(m_hFle, FSCTL_MOVE_FILE, &mfd, sizeof(MOVE_FILE_DATA),
                                       NULL, 0, &dwReturnBytes, NULL);
               if (!bIsOk)
               {
                   rerCod = GetLastError();
                   return FALSE;
               }
               else
               {
                   rmapList.erase(ite);
               }
           }

           ull_dealedVcnInBlock += mfd.ClusterCount;
       }   //while

    }   //for

    return TRUE;
}
*/

BOOL MovFle::move(HANDLE hVolum, std::map &rmapList, DWORD &rerCod)
{
    if (!m_mptr)
    {
       cout << "null function pointer" << endl;
       return FALSE;
    }

    MOVEFILE_DESCRIPTOR   mfd;
    mfd.FileHandle = m_hFle;
    DWORD   status = 0;
    IO_STATUS_BLOCK ioStatus;

    BOOL bIsOk = TRUE;
    DWORD dwReturnBytes = 0;

    ULONGLONG ull_startVcnInBlock = 0;

    if (rmapList.empty())
    {
       return FALSE;
    }

    map::iterator ite = rmapList.begin();

    for (map::const_iterator cit = m_mapAnalysised.begin(); cit != m_mapAnalysised.end(); ++ cit)
    {
       //check rmaplist size
       if (rmapList.size() == 0)
       {
           return FALSE;
       }

       //deal each block
       ULONGLONG ull_vcnInBlock = cit -> second;
       ULONGLONG ull_dealedVcnInBlock = 0;
       ull_startVcnInBlock = cit -> first;

       while (ull_dealedVcnInBlock < ull_vcnInBlock)
       {
           //check rmapList size
           if (rmapList.size() == 0)
           {
               return FALSE;
           }

           ite = rmapList.begin();   //always points to the first item

           if (ull_vcnInBlock - ull_dealedVcnInBlock <= ite -> second)   //space is enough
           {
               if (ull_vcnInBlock - ull_dealedVcnInBlock == ite -> second)   //==
               {
                   mfd.NumVcns = ite -> second;
                   mfd.StartVcn.QuadPart = ull_startVcnInBlock + ull_dealedVcnInBlock;
                   mfd.TargetLcn.QuadPart = ite -> first;

                   /*
                   bIsOk = DeviceIoControl(m_hFle, FSCTL_MOVE_FILE, &mfd, sizeof(MOVE_FILE_DATA),
                       NULL, 0, &dwReturnBytes, NULL);
                   */

                   status = m_mptr( hVolum, NULL, NULL, 0, &ioStatus,
                       FSCTLMOVEFILE,
                       &mfd, sizeof(mfd),
                       NULL, 0 );

                   //
                   // If the operation is pending, wait for it to finish
                   //
                   if( status == STATUS_PENDING ) {

                       WaitForSingleObject(m_hFle, INFINITE);
                       status = ioStatus.Status;
                   }

                   if (status != STATUS_SUCCESS)
                   {
                       rerCod = status;
                       return FALSE;
                   }
                   else
                   {
                       rmapList.erase(ite);
                   }
               }
               else   //<
               {
                   mfd.NumVcns = ull_vcnInBlock - ull_dealedVcnInBlock;
                   mfd.StartVcn.QuadPart = ull_startVcnInBlock + ull_dealedVcnInBlock;
                   mfd.TargetLcn.QuadPart = ite -> first;

                   /*
                   bIsOk = DeviceIoControl(m_hFle, FSCTL_MOVE_FILE, &mfd, sizeof(MOVE_FILE_DATA),
                       NULL, 0, &dwReturnBytes, NULL);
                   */

                   status = m_mptr( hVolum, NULL, NULL, 0, &ioStatus,
                                           FSCTLMOVEFILE,
                                           &mfd, sizeof(mfd),
                                           NULL, 0 );
                   if( status == STATUS_PENDING ) {

                       WaitForSingleObject(m_hFle, INFINITE);
                       status = ioStatus.Status;
                   }

                   if (status != STATUS_SUCCESS)
                   {
                       rerCod = status;
                       return FALSE;
                   }
                   else
                   {
                       pair tmppar = *ite;
                       rmapList.erase(ite);
                       rmapList.insert(make_pair(tmppar.first + mfd.NumVcns, tmppar.second - mfd.NumVcns));
                   }
               }
           }
           else   //>   space is not enough
           {
               mfd.NumVcns = ite -> second;
               mfd.StartVcn.QuadPart = ull_startVcnInBlock + ull_dealedVcnInBlock;
               mfd.TargetLcn.QuadPart = ite -> first;

               /*
               bIsOk = DeviceIoControl(m_hFle, FSCTL_MOVE_FILE, &mfd, sizeof(MOVE_FILE_DATA),
                   NULL, 0, &dwReturnBytes, NULL);
               */
               status = m_mptr( hVolum, NULL, NULL, 0, &ioStatus,
                                          FSCTLMOVEFILE,
                                          &mfd, sizeof(mfd),
                                          NULL, 0 );

               //
               // If the operation is pending, wait for it to finish
               //
               if( status == STATUS_PENDING ) {

                   WaitForSingleObject(m_hFle, INFINITE);
                   status = ioStatus.Status;
               }

               if (status != STATUS_SUCCESS)
               {
                   rerCod = status;
                   return FALSE;
               }
               else
               {
                   rmapList.erase(ite);
               }
           }

           ull_dealedVcnInBlock += mfd.NumVcns;
       }   //while

    }   //for

    return TRUE;
}

#ifndef VOLTDY_H
#define VOLTDY_H

#include "bitmap.h"
#include
#include
#include
using namespace std;
#include "windows.h"
#include "ddk.h"

class VolTdy
{
public:
    BOOL initVolume(string str_volumeName, MyNtFsControlFile ptr);
    BOOL getMapLst(DWORD &rerCod);
    void beginBowse();
    ~VolTdy();
private:
    void browse(string strdir);
    map m_mapLst;
    HANDLE m_hVolum;
    string m_volumeName;
    ULONGLONG ull_usedClusters;
    MyNtFsControlFile m_ptr;
    fstream fleLog;
};

#endif

#include "voltdy.h"
#include
#include "movfle.h"

BOOL VolTdy::initVolume(string str_volumeName, MyNtFsControlFile ptr)
{
    m_volumeName = str_volumeName[0];
    m_volumeName += ":";
    m_volumeName = "////.//" + m_volumeName;

    m_hVolum = CreateFile(m_volumeName.c_str(), /*FILE_READ_DATA | FILE_WRITE_DATA |FILE_APPEND_DATA | FILE_EXECUTE | FILE_READ_ATTRIBUTES | */GENERIC_READ/* | GENERIC_WRITE*/,
                       FILE_SHARE_READ | FILE_SHARE_WRITE , NULL, OPEN_EXISTING,
                       /*FILE_ATTRIBUTE_NORMAL*/ 0, NULL);
    if (INVALID_HANDLE_VALUE == m_hVolum)
    {
       return FALSE;
    }

    //for browse use
    m_volumeName = str_volumeName[0];
    m_volumeName += "://*";

    ull_usedClusters = 0;
    m_ptr = ptr;
    return TRUE;
}

VolTdy::~VolTdy()
{
    if (m_hVolum != INVALID_HANDLE_VALUE)
    {
       CloseHandle(m_hVolum);
    }
}

BOOL VolTdy::getMapLst(DWORD &rerCod)
{
    BOOL bIsOk;
    STARTING_LCN_INPUT_BUFFER start_lcn_buf;
    start_lcn_buf.StartingLcn.QuadPart = 0;
    VOLUME_BITMAP_BUFFER bitmap_buf_org;
    VOLUME_BITMAP_BUFFER *pbitmap_buf = 0;
    DWORD dwOutSize = 0;
    ULONGLONG ullNumClusters = 0;
    DWORD dwReturnBytes = 0;

    bIsOk = DeviceIoControl(m_hVolum, FSCTL_GET_VOLUME_BITMAP, &start_lcn_buf, sizeof(STARTING_LCN_INPUT_BUFFER),
                           &bitmap_buf_org, sizeof(VOLUME_BITMAP_BUFFER), &dwReturnBytes, NULL);
    if (!bIsOk && GetLastError() == ERROR_MORE_DATA)
    {
       //debug
       ullNumClusters = bitmap_buf_org.BitmapSize.QuadPart - bitmap_buf_org.StartingLcn.QuadPart;
       dwOutSize = ullNumClusters/sizeof(byte) + sizeof(VOLUME_BITMAP_BUFFER);
       pbitmap_buf = (VOLUME_BITMAP_BUFFER *)new byte[dwOutSize];
       if (!pbitmap_buf)   return FALSE;

       bIsOk = DeviceIoControl(m_hVolum, FSCTL_GET_VOLUME_BITMAP, &start_lcn_buf, sizeof(start_lcn_buf),
                               pbitmap_buf, dwOutSize, &dwReturnBytes, NULL);
       if (!bIsOk)
       {
           if (pbitmap_buf)
           {
               delete [] pbitmap_buf;
               pbitmap_buf = 0;
           }
           rerCod = GetLastError();
           return FALSE;
       }
    }

    BitMap bitmap;
    bitmap.getMapList(pbitmap_buf);

    delete [] pbitmap_buf;
    pbitmap_buf = 0;

    bitmap.dispalyMapListOfFree();
    m_mapLst = bitmap.returnMaplist();

    ull_usedClusters = count(bitmap.returnBitVec().begin(), bitmap.returnBitVec().end(), true);
    cout << ull_usedClusters << "ull_usedClusters" << endl;

//   bitmap.showVecOfBit();

    return TRUE;
}

void VolTdy::browse(string strdir) //strdir, for directory, sample "F:/*"
{
    WIN32_FIND_DATAA wfd;
    HANDLE m_hFle = FindFirstFile(strdir.c_str(), &wfd);
    strdir.resize(strdir.size() - 1);

    DWORD errCod = 0;
    if (INVALID_HANDLE_VALUE != m_hFle)
    {
       do
       {
           string str_fullName;
           errCod = 0;

           //directory dealed code
           if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
           {
               string tmp = wfd.cFileName;
               if ((tmp != ".") && (tmp != ".."))
               {
                   string stedbg = wfd.cFileName;
                   str_fullName = strdir + stedbg;

                   //for desturctor run
                   {
                       MovFle mvf;
                       fleLog.open("volLog.txt", ios_base::app);

                       fleLog << str_fullName << endl;
                       if(mvf.init(str_fullName, m_ptr))
                       {
                           errCod = 0;
                           if(mvf.analysis(ull_usedClusters, errCod))
                           {
                               errCod = 0;
                               if(mvf.move(m_hVolum, m_mapLst, errCod));
                               else fleLog << " mov ->" << str_fullName << endl << "errCod" << " = " << errCod << endl;
                           }
                           else
                               fleLog << " ana ->" << str_fullName << endl << "errCod" << " = " << errCod << endl;
                       }
                       else fleLog << " ini ->" << str_fullName << endl;
                       fleLog.close();
                   }

                   str_fullName += "//*";
                   browse(str_fullName);
               }
           }
           //file dealed code
           else
           {
               string stedbg = wfd.cFileName;
               str_fullName = strdir + stedbg;

               MovFle mvf;

               fleLog.open("volLog.txt", ios_base::app);
               fleLog << str_fullName << endl;
               if(mvf.init(str_fullName, m_ptr))
               {
                   errCod = 0;
                   if(mvf.analysis(ull_usedClusters, errCod))
                   {
                       errCod = 0;

                       //dbg
                       cout << "start mov " << str_fullName << endl;

                       if(mvf.move(m_hVolum, m_mapLst, errCod));
                       else fleLog << " mov ->" << str_fullName << endl << "errCod" << " = " << errCod << endl;
                   }
                   else
                       fleLog << " ana ->" << str_fullName << endl << "errCod" << " = " << errCod << endl;
               }
               else fleLog << " ini ->" << str_fullName << endl;
               fleLog.close();
           }
       } while(FindNextFile(m_hFle, &wfd));
    }

    if (INVALID_HANDLE_VALUE != m_hFle)
    {
       FindClose(m_hFle);
    }
}

void VolTdy::beginBowse()
{
    browse(m_volumeName);
}

#ifndef DDK_H
#define DDK_H

#define FSCTLMOVEFILE                   0x90074

//
// return code type
//
typedef UINT NTSTATUS;

//
// Error codes returned by NtFsControlFile (see NTSTATUS.H)
//
#define STATUS_SUCCESS                     ((NTSTATUS)0x00000000L)
#define STATUS_BUFFER_OVERFLOW           ((NTSTATUS)0x80000005L)
#define STATUS_INVALID_PARAMETER         ((NTSTATUS)0xC000000DL)
#define STATUS_BUFFER_TOO_SMALL          ((NTSTATUS)0xC0000023L)
#define STATUS_ALREADY_COMMITTED         ((NTSTATUS)0xC0000021L)
#define STATUS_INVALID_DEVICE_REQUEST    ((NTSTATUS)0xC0000010L)

//--------------------------------------------------------------------
//       F S C T L S P E C I F I C   T Y P E D E F S
//--------------------------------------------------------------------

//
// This is the definition for a VCN/LCN (virtual cluster/logical cluster)
// mapping pair that is returned in the buffer passed to
// FSCTL_GET_RETRIEVAL_POINTERS
//
typedef struct {
    ULONGLONG           Vcn;
    ULONGLONG           Lcn;
} MAPPING_PAIR, *PMAPPING_PAIR;

//
// This is the definition for the buffer that FSCTL_GET_RETRIEVAL_POINTERS
// returns. It consists of a header followed by mapping pairs
//
typedef struct {
    ULONG               NumberOfPairs;
    ULONGLONG           StartVcn;
    MAPPING_PAIR       Pair[1];
} GET_RETRIEVAL_DESCRIPTOR, *PGET_RETRIEVAL_DESCRIPTOR;

//
// This is the definition of the buffer that FSCTL_GET_VOLUME_BITMAP
// returns. It consists of a header followed by the actual bitmap data
//
typedef struct {
    ULONGLONG           StartLcn;
    ULONGLONG           ClustersToEndOfVol;
    BYTE               Map[1];
} BITMAP_DESCRIPTOR, *PBITMAP_DESCRIPTOR;

//
// This is the definition for the data structure that is passed in to
// FSCTL_MOVE_FILE
//
typedef struct {
    HANDLE            FileHandle;
    ULONG             Reserved;
    LARGE_INTEGER     StartVcn;
    LARGE_INTEGER     TargetLcn;
    ULONG             NumVcns;
    ULONG             Reserved1;
} MOVEFILE_DESCRIPTOR, *PMOVEFILE_DESCRIPTOR;

/*
typedef struct {
    HANDLE            FileHandle;
    ULONGLONG             Reserved;
    LARGE_INTEGER     StartVcn;
    LARGE_INTEGER     TargetLcn;
    ULONGLONG             NumVcns;
    ULONGLONG             Reserved1;
} MOVEFILE_DESCRIPTOR, *PMOVEFILE_DESCRIPTOR;
*/

//--------------------------------------------------------------------
//     N T F S C O N T R O L F I L E   D E F I N I T I O N S
//--------------------------------------------------------------------

//
// Prototype for NtFsControlFile and data structures
// used in its definition
//

//
// Io Status block (see NTDDK.H)
//
typedef struct _IO_STATUS_BLOCK {
    NTSTATUS Status;
    ULONG Information;
} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;

//
// Apc Routine (see NTDDK.H)
//
typedef VOID (*PIO_APC_ROUTINE) (
                               PVOID ApcContext,
                               PIO_STATUS_BLOCK IoStatusBlock,
                               ULONG Reserved
                               );

//typedef int (*MYPROC)(LPTSTR);
typedef NTSTATUS (__stdcall *MyNtFsControlFile)(
                                      HANDLE FileHandle,
                                      HANDLE Event,                   // optional
                                      PIO_APC_ROUTINE ApcRoutine,       // optional
                                      PVOID ApcContext,               // optional
                                      PIO_STATUS_BLOCK IoStatusBlock,
                                      ULONG FsControlCode,
                                      PVOID InputBuffer,               // optional
                                      ULONG InputBufferLength,
                                      PVOID OutputBuffer,               // optional
                                      ULONG OutputBufferLength
                                      );

#endif

#include "voltdy.h"
#include
#include "windows.h"
#include "ddk.h"

int main(int argc, char **argv)
{
    DWORD dwTime = GetTickCount();

    //get ntfscontrolfile pointer
    MyNtFsControlFile ntp = NULL;
    ntp = (MyNtFsControlFile) GetProcAddress( GetModuleHandle("ntdll.dll"),"NtFsControlFile");
    if(!ntp)
    {
       cout << "Could not find NtFsControlFile entry point in NTDLL.DLL/n";
       return 1;
    }

    //clean log file
    fstream outfle("volLog.txt", ios_base::out);
    if (!outfle)
    {
       cout << "err clean log" << endl;
    }
    outfle.close();

    //choose the disk
    cout << "Please input disk : ";
    string strdic;
    cin >> strdic;

    //run
    VolTdy vtd;
    BOOL bIsOk = vtd.initVolume(strdic, ntp); //ok
    if (!bIsOk)
    {
       cout << "err initVolume function" << endl;
       return 1;
    }

    DWORD errCod = 0;
    bIsOk = vtd.getMapLst(errCod); //ok
    if (!bIsOk)
    {
       cout << "err getMapLst function" << endl;
       return 1;
    }

    vtd.beginBowse(); //ok

    cout<< GetTickCount() - dwTime<
    return 0;
}

c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
扫地机类清洁产品之直流无刷电机控制悟空胆好小清洁服务机器人单片机人工智能
扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
2018-07-23-催眠日作业-#不一样的31天#-66小鹿小鹿_33
预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
《大清方方案》| 第二话谁佐清欢
和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
《庄子.达生9》钱江潮369
【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
2020-04-12每天三百字之连接与替代冷眼看潮
不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
东南林氏之九牧林候选父系祖缘树TheYtree
渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
大伟说成语之唉声叹气求索大伟
＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
libyuv之linux编译 jaronho Linux linux 运维服务器
文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
怎么做淘客赚钱(2022最新免费淘客盈利的方法) 高省_飞智666600
很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
锁之缘尘缘诗词原创作品
是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
ARM驱动学习之基础小知识 JT灬新一 ARM 嵌入式 arm开发学习
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
ARM驱动学习之4小结 JT灬新一嵌入式 C++arm开发学习 linux
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
C++菜鸟教程 - 从入门到精通第二节 DreamByte c++
一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
2020-12-24 我和我的天使们
阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
18、架构-可观测性之聚合度量大树~~ 架构 java python 后端架构
聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
学习“论语”-第59天春峰轩
12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
2021-11-15 宙火
我给宋小姐写了首诗，是我在课上因思恋宋小姐而写的。“自古多情是唐宋，从来双飞归巢燕。邻家小女相聘婷，常使春意荡漾我。不知单思可为爱，惟愿一心付之汝。”我拿给宋小姐看了，她说我写得很棒。我很开心，但又不是那么开心。宋小姐是回复我了，但也只是说我写得很棒，对我诗句中蕴藏的真切感情，不知道是真的没发现，还是装作没发现。但我不深究，只是这样，我就很开心了。我答应宋小姐，一天给她写一首诗。
《我的青葱岁月之缘来是你》第二章迎新晚会思源思缘思怨
“怎么你也来了这里？”我愉快的问到，想着这是上天给的缘分吗？我还没去找他竟然就相遇了。那个让我开心的老乡。“你好，我也是舞蹈社的新人啊！”他说，笑起来回答我，眼睛弯弯的。“这么巧，我叫吴倩，你叫啥？”“我叫韩欢，你也是B市人吧，c中毕业的？”“我不是，我是f中的，不然肯定会认识你的”“是吗？以后多多关照了”他还冲我眨了眨眼睛。内心一阵悸动，这是……回到寝室，我兴奋的告诉我的室友这个事情，我再次觉得
数据结构之哈希表 X同学的开始数据结构数据结构散列表
哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
厦门自由行之第一天: 大苏子在广漂
厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
“这才好”麻辣香锅能够增加人身体的免疫能力小补文知
我就来介绍一种香锅，那就是“这才好”麻辣香锅，它产出于著名的蜀地文化，具有悠久的历史土家风味，麻辣鲜香，健康安全。采用传统秘制麻辣香锅油辣子，还有贴心加料“孜然包”满足人们的不同口味需求，香锅底料辣椒，微辣且香，含有丰富微量元素和维生素，具有辣而不躁，味道纯正，醇厚温和。花椒采用历史悠久，被列为宫廷供品的“贡椒”的汉源花椒。我们还挑选了“川菜之魂”郫县豆瓣的鼻祖品牌豆瓣，保留最原始的郫县豆瓣味道，
Spring的注解积累 yijiesuifeng spring 注解
用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。如：在base-package指明一个包 <context:component-sc
传感器百合不是茶 android 传感器
android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件下面就以重力传感器为例; 1,在onCreate中获得传感器服务 private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
[光磁与探测]金吕玉衣的意义 comsci
这是一个古代人的秘密:现在告诉大家信不信由你们: 穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星这就是为什么古代
精简的反序打印某个数沐刃青蛟打印
以前看到一些让求反序打印某个数的程序。比如：输入123，输出321。记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。似乎最后是用到%和/方法解决的。而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）代码如下： long num, num1=0;
PHP：6种方法获取文件的扩展名 IT独行者 PHP 扩展名
PHP：6种方法获取文件的扩展名 1、字符串查找和截取的方法 1 $extension = substr ( strrchr ( $file , '.' ), 1); 2、字符串查找和截取的方法二 1 $extension = substr
面试111 文强chu 面试
1事务隔离级别有那些，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器（一次） 4 过滤器和拦截器的区别（频率也挺高） 5 final，finally final
XML的四种解析方式小桔子 dom jdom dom4j sax
在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。　　预备　　测试环境：　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
wordpress中常见的操作 aichenglong 中文注册 wordpress 移除菜单
1 wordpress中使用中文名注册解决办法 1)使用插件 2)修改wp源代码进入到wp-include/formatting.php文件中找到 function sanitize_user( $username, $strict = false
小飞飞学管理-1 alafqq 管理
项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。结合我自己经历写下心得对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
IO输入输出部分探讨百合不是茶 IO
//文件处理在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */ //1，运用File类对文件目录和属性进行操作 //在工程中线创建一个text.txt
getElementById的用法 bijian1013 element
getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。返回具有指定ID属性值的第一个对象的一个引用。语法： &n
励志经典语录 bijian1013 励志人生
经典语录1: 哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
[MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。本篇介绍MongoDB的切片(Sharding) 1.何时需要分片 &nbs
【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
yum方式部署zabbix ronin47 yum方式部署zabbix
安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EE Hibernate4
今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
Netty源码学习-FrameDecoder bylijinnan java netty
Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
SQL行列转换方法 chicony 行列转换
create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
中文编码测试 ctrain 编码
循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
hive 客户端查询报堆内存溢出解决方法 daizj hive 堆内存溢出
hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 问题原因： hive堆内存默认为256M 这个问题的解决方法为：修改/us
人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
Eclipse简单有用的配置 dcj3sjt126com eclipse
1、显示行号 Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers 2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
在tomcat上面安装solr4.8.0全过程 eksliang Solr solr4.0后的版本安装 solr4.8.0安装
转载请出自出处： http://eksliang.iteye.com/blog/2096478 首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了第一步：当然是下载去官网上下载最新的solr版本，下载地址
Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞 android APP 分析
点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。 0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。针对序列化对象而出现的拒绝服务主要
HoverTree项目已经实现分层 hvt 编程 .net Web C#ASP.ENT
HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
Google Maps API v3: Remove Markers 移除标记天梯梦 google maps api
Simply do the following: I. Declare a global variable: var markersArray = []; II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
jQuery选择器总结 lq38366 jquery 选择器
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
基础数据结构和算法六：Quick sort sunwinner Algorithm Quicksort
Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作刘星宇 html Web
今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。方法如下：
Mybatis实用Mapper SQL汇总示例 wdmcygah sql mysql mybatis 实用
Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，

隐藏api的磁盘数据移动程序

你可能感兴趣的:(学习笔记之C＋＋)