您现在的位置：计算机技术学习网 > 技术中心 > 编程开发 > C >

vhd 转换为img源码，由VS2010 C++编译

来源：未知 责任编辑：责任编辑 发表时间:2013-08-27 15:58　点击:次
c#Cjava.net移动开发GO语言PerlPython

//51CTO首发此文，转载请保留完整信息

本工程主要由vhd2img.cpp layout.h组成,C代码实现。

vhd2img.cpp：

  1. // vhd2img.cpp : 定义控制台应用程序的入口点。 
  2. //by www.frombyte.cn zhangyu 
  3. //北亚数据恢复中心(www.sjhf.net)张宇 2012/1/6 发表于51cto
  4.  
  5. #include "stdafx.h" 
  6. #include <windows.h> 
  7. #include "layout.h" 
  8. #define VHD_OPENED 1 
  9. #define VHD_UNOPEN 0 
  10. #define BIT_MASK 0x80 
  11. static inline int test_bit (byte *addr, u32 nr) 
  12. { 
  13.     return ((addr[nr >> 3] << (nr & 7)) & BIT_MASK) != 0; 
  14. }; 
  15. static inline void set_bit (byte *addr, u32 nr) 
  16. { 
  17.     addr[nr >> 3] |= (BIT_MASK >> (nr & 7)); 
  18. } 
  19.  
  20. HANDLE hIn,hOut; 
  21.  
  22. struct vhd_info 
  23. { 
  24.     u64 uSize; 
  25.     u32 *bat; 
  26.     byte *batmap; 
  27.     u64 uBlkSize; 
  28.     u64 uBatNum; 
  29.     u32 spb; //secters per block 
  30.     u32 log2spb; 
  31.     u32 vhd_status; 
  32.     bool is_have_batmap; 
  33. }; 
  34.  
  35.  
  36. int open_vhd(TCHAR *name,vhd_info &vhd) 
  37. { 
  38.     hd_ftr vhd_head; 
  39.     hIn = CreateFile(name,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL); 
  40.     if(hIn == INVALID_HANDLE_VALUE) 
  41.     { 
  42.         _tprintf(_T("ERROR%d:source VHD file open error!\n"),GetLastError()); 
  43.         return -1; 
  44.     } 
  45.     DWORD bRead; 
  46.     ReadFile(hIn,(char*)&vhd_head,sizeof(hd_ftr),&bRead,NULL); 
  47.     if(bRead != sizeof(hd_ftr)) 
  48.         return -2; 
  49.     if(strncmp(vhd_head.cookie,HD_COOKIE,8) != 0) 
  50.     { 
  51.         _tprintf(_T("the source file is not a valid VHD format!\n")); 
  52.         return -3; 
  53.     } 
  54.     if( (LE32(vhd_head.type) != HD_TYPE_DYNAMIC) && (LE32(vhd_head.type) != HD_TYPE_DIFF) ) 
  55.         return -4; 
  56.  
  57.     dd_hdr vhd_sparce; 
  58.     ReadFile(hIn,(char*)&vhd_sparce,sizeof(dd_hdr),&bRead,NULL); 
  59.     if(bRead != sizeof(dd_hdr)) 
  60.         return -5; 
  61.     if(strncmp(vhd_sparce.cookie,DD_COOKIE,8) != 0) 
  62.         return -6; 
  63.     vhd.uBlkSize = LE32(vhd_sparce.block_size); 
  64.     vhd.uBatNum = LE32(vhd_sparce.max_bat_size); 
  65.     vhd.bat = new u32 [vhd.uBatNum]; 
  66.     LARGE_INTEGER liPoi,liNew; 
  67.     liPoi.QuadPart = LE64(vhd_sparce.table_offset); 
  68.     SetFilePointerEx(hIn,liPoi,&liNew,FILE_BEGIN); 
  69.     ReadFile(hIn,vhd.bat,vhd.uBatNum * sizeof(u32),&bRead,NULL); 
  70.     if(bRead != vhd.uBatNum * sizeof(u32)) 
  71.         return -7; 
  72.  
  73.     dd_batmap_hdr batmap_head; 
  74.     ReadFile(hIn,(char*)&batmap_head,sizeof(dd_batmap_hdr),&bRead,NULL); 
  75.     if(bRead != sizeof(dd_batmap_hdr)) 
  76.         return -8; 
  77.     if(strncmp(batmap_head.cookie,VHD_BATMAP_COOKIE,8) != 0) 
  78.         vhd.is_have_batmap = FALSE; 
  79.     else 
  80.         vhd.is_have_batmap = TRUE; 
  81.  
  82.     vhd.spb = vhd.uBlkSize >> VHD_SECTOR_SHIFT; 
  83.     vhd.vhd_status = VHD_OPENED; 
  84.     return 1; 
  85. } 
  86. int read_vhd(vhd_info &vhd,byte* buf,u32 blkno) 
  87. { 
  88.     byte spb_bitmap[VHD_SECTOR_SIZE];  
  89.     DWORD bRead; 
  90.     if(vhd.bat[blkno] == 0xFFFFFFFF) 
  91.         return 2; 
  92.     byte *tbuf = new byte [vhd.uBlkSize]; 
  93.     LARGE_INTEGER liPoi,liNew; 
  94.     liPoi.QuadPart = (u64)(LE32(vhd.bat[blkno])) << VHD_SECTOR_SHIFT; 
  95.     SetFilePointerEx(hIn,liPoi,&liNew,FILE_BEGIN); 
  96.     ReadFile(hIn,spb_bitmap,VHD_SECTOR_SIZE,&bRead,NULL); 
  97.     if(bRead != VHD_SECTOR_SIZE) 
  98.     { 
  99.         delete [] tbuf; 
  100.         return -2; 
  101.     } 
  102.     ReadFile(hIn,tbuf,vhd.uBlkSize,&bRead,NULL); 
  103.     if(bRead != vhd.uBlkSize) 
  104.     { 
  105.         delete [] tbuf; 
  106.         return -3; 
  107.     } 
  108.     for(u32 i=0;i<vhd.spb;i++) 
  109.     { 
  110.         if(test_bit(spb_bitmap,i)) //位为1，表示磁盘上有数据，需要拷贝 
  111.         { 
  112.             memcpy(buf + i * VHD_SECTOR_SIZE,tbuf + i*VHD_SECTOR_SIZE,VHD_SECTOR_SIZE); 
  113.         } 
  114.     } 
  115.     delete [] tbuf; 
  116.     return 1; 
  117. } 
  118.  
  119. int _tmain(int argc, _TCHAR* argv[]) 
  120. { 
  121.     if(argc != 3)  
  122.     {        
  123.         _tprintf(_T("vhd2img.exe <input vhd name> <output file/disk name>\n")); 
  124.         _tprintf(_T("eg. vhd2img.exe my.vhd d:\\my.img \n")); 
  125.         _tprintf(_T("    vhd2img.exe my.vhd \"\\\\.\\physicaldrive1\" (write to hardisk 1)\n")); 
  126.         return 0; 
  127.     } 
  128.  
  129.     vhd_info vhd; 
  130.  
  131.     //打开输入vhd 
  132.     if(open_vhd(argv[1],vhd) != 1) 
  133.         return -1; 
  134.  
  135.     //生成目标文件 
  136.     HANDLE hOut = CreateFile(argv[2],GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,NULL); 
  137.     if(hOut == INVALID_HANDLE_VALUE) 
  138.     { 
  139.         hOut = CreateFile(argv[2],GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_ALWAYS,0,NULL); 
  140.         if(hOut == INVALID_HANDLE_VALUE) 
  141.         { 
  142.             _tprintf(_T("ERROR%d:the dest disk/file open error!\n"),GetLastError()); 
  143.             return -1; 
  144.         } 
  145.     } 
  146.     //u32 nBlkSize = vhd.uBlkSize; 
  147.     byte* buf = new byte [vhd.uBlkSize]; 
  148.     u32 nBitmapSize = (vhd.spb >> 3 ); 
  149.     byte* bitmap = new byte [nBitmapSize]; 
  150.     DWORD bWrite; 
  151.     LARGE_INTEGER liPos,liNew; 
  152.  
  153.     for(int i=0;i<vhd.uBatNum;i++)  
  154.     { 
  155.         memset(buf,0,vhd.uBlkSize); 
  156.         memset(bitmap,0,nBitmapSize); 
  157.         if(read_vhd(vhd,buf,i) != 1) //读错误或属于稀疏空间 
  158.             continue; 
  159.         liPos.QuadPart = (u64)i * (u64)vhd.uBlkSize; 
  160.         SetFilePointerEx(hOut,liPos,&liNew,FILE_BEGIN); 
  161.         WriteFile(hOut,buf,vhd.uBlkSize,&bWrite,NULL); 
  162.         if(bWrite != vhd.uBlkSize) 
  163.         { 
  164.             _tprintf(_T("ERROR%d:#%dblk (2MB) write error!\n\n"),GetLastError(),i); 
  165.             return -1; 
  166.         } 
  167.     } 
  168.  
  169.     liPos.QuadPart = (u64)vhd.uBatNum * (u64)vhd.uBlkSize; 
  170.     SetFilePointerEx(hOut,liPos,&liNew,FILE_BEGIN); 
  171.     SetEndOfFile(hOut); 
  172.  
  173.     //释放 
  174.     delete [] buf; 
  175.     delete [] bitmap; 
  176.     CloseHandle(hIn); 
  177.     CloseHandle(hOut); 
  178.  
  179.     return 1; 
  180.  
  181. } 
  182.  

layout.h:

 

  1. /* Copyright (c) 2008, XenSource Inc. 
  2.  * All rights reserved. 
  3.  * 
  4.  * Redistribution and use in source and binary forms, with or without 
  5.  * modification, are permitted provided that the following conditions are met: 
  6.  *     * Redistributions of source code must retain the above copyright 
  7.  *       notice, this list of conditions and the following disclaimer. 
  8.  *     * Redistributions in binary form must reproduce the above copyright 
  9.  *       notice, this list of conditions and the following disclaimer in the 
  10.  *       documentation and/or other materials provided with the distribution. 
  11.  *     * Neither the name of XenSource Inc. nor the names of its contributors 
  12.  *       may be used to endorse or promote products derived from this software 
  13.  *       without specific prior written permission. 
  14.  * 
  15.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
  16.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
  17.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
  18.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
  19.  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
  20.  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
  21.  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
  22.  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
  23.  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
  24.  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
  25.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  26. */ 
  27. typedef UINT32 u32; 
  28. typedef UINT64 u64; 
  29. typedef unsigned char   vhd_uuid_t[16]; 
  30. #ifndef __VHD_H__ 
  31. #define __VHD_H__ 
  32.  
  33.  
  34. #define DEBUG 1 
  35.  
  36. /* ---------------------------------------------------------------------- */ 
  37. /* General definitions.                                                   */ 
  38. /* ---------------------------------------------------------------------- */ 
  39.  
  40. #define VHD_SECTOR_SIZE  512 
  41. #define VHD_SECTOR_SHIFT   9 
  42.  
  43. /* ---------------------------------------------------------------------- */ 
  44. /* This is the generic disk footer, used by all disks.                    */ 
  45. /* ---------------------------------------------------------------------- */ 
  46.  
  47. struct hd_ftr { 
  48.   char   cookie[8];       /* Identifies original creator of the disk      */ 
  49.   u32    features;        /* Feature Support -- see below                 */ 
  50.   u32    ff_version;      /* (major,minor) version of disk file           */ 
  51.   u64    data_offset;     /* Abs. offset from SOF to next structure       */ 
  52.   u32    timestamp;       /* Creation time.  secs since 1/1/2000GMT       */ 
  53.   char   crtr_app[4];     /* Creator application                          */ 
  54.   u32    crtr_ver;        /* Creator version (major,minor)                */ 
  55.   u32    crtr_os;         /* Creator host OS                              */ 
  56.   u64    orig_size;       /* Size at creation (bytes)                     */ 
  57.   u64    curr_size;       /* Current size of disk (bytes)                 */ 
  58.   u32    geometry;        /* Disk geometry                                */ 
  59.   u32    type;            /* Disk type                                    */ 
  60.   u32    checksum;        /* 1's comp sum of this struct.                 */ 
  61.   vhd_uuid_t uuid;        /* Unique disk ID, used for naming parents      */ 
  62.   char   saved;           /* one-bit -- is this disk/VM in a saved state? */ 
  63.   char   hidden;          /* tapdisk-specific field: is this vdi hidden?  */ 
  64.   char   reserved[426];   /* padding                                      */ 
  65. }; 
  66.  
  67. /* VHD cookie string. */ 
  68. static const char HD_COOKIE[9]  =  "conectix"; 
  69.  
  70. /* Feature fields in hd_ftr */ 
  71. #define HD_NO_FEATURES     0x00000000 
  72. #define HD_TEMPORARY       0x00000001 /* disk can be deleted on shutdown */ 
  73. #define HD_RESERVED        0x00000002 /* NOTE: must always be set        */ 
  74.  
  75. /* Version field in hd_ftr */ 
  76. #define HD_FF_VERSION      0x00010000 
  77.  
  78. /* Known creator OS type fields in hd_ftr.crtr_os */ 
  79. #define HD_CR_OS_WINDOWS   0x5769326B /* (Wi2k) */ 
  80. #define HD_CR_OS_MACINTOSH 0x4D616320 /* (Mac ) */ 
  81.  
  82. /* 
  83.  * version 0.1:  little endian bitmaps 
  84.  * version 1.1:  big endian bitmaps; batmap 
  85.  * version 1.2:  libvhd 
  86.  * version 1.3:  batmap version bump to 1.2 
  87.  */ 
  88. #define VHD_VERSION(major, minor)  (((major) << 16) | ((minor) & 0x0000FFFF)) 
  89. #define VHD_CURRENT_VERSION        VHD_VERSION(1, 3) 
  90.  
  91. /* Disk geometry accessor macros. */ 
  92. /* Geometry is a triple of (cylinders (2 bytes), tracks (1 byte), and  
  93.  * secotrs-per-track (1 byte))  
  94.  */ 
  95. #define GEOM_GET_CYLS(_g)  (((_g) >> 16) & 0xffff) 
  96. #define GEOM_GET_HEADS(_g) (((_g) >> 8)  & 0xff) 
  97. #define GEOM_GET_SPT(_g)   ((_g) & 0xff) 
  98.  
  99. #define GEOM_ENCODE(_c, _h, _s) (((_c) << 16) | ((_h) << 8) | (_s)) 
  100.  
  101. /* type field in hd_ftr */ 
  102. #define HD_TYPE_NONE       0 
  103. #define HD_TYPE_FIXED      2  /* fixed-allocation disk */ 
  104. #define HD_TYPE_DYNAMIC    3  /* dynamic disk */ 
  105. #define HD_TYPE_DIFF       4  /* differencing disk */ 
  106.  
  107. /* String table for hd.type */ 
  108. static const char *HD_TYPE_STR[7] = { 
  109.         "None",                    /* 0 */ 
  110.         "Reserved (deprecated)",   /* 1 */ 
  111.         "Fixed hard disk",         /* 2 */ 
  112.         "Dynamic hard disk",       /* 3 */ 
  113.         "Differencing hard disk",  /* 4 */ 
  114.         "Reserved (deprecated)",   /* 5 */ 
  115.         "Reserved (deprecated)"    /* 6 */ 
  116. }; 
  117.  
  118. #define HD_TYPE_MAX 6 
  119.  
  120. struct prt_loc { 
  121.   u32    code;            /* Platform code -- see defines below.          */ 
  122.   u32    data_space;      /* Number of 512-byte sectors to store locator  */ 
  123.   u32    data_len;        /* Actual length of parent locator in bytes     */ 
  124.   u32    res;             /* Must be zero                                 */ 
  125.   u64    data_offset;     /* Absolute offset of locator data (bytes)      */ 
  126. }; 
  127.  
  128. /* Platform Codes */ 
  129. #define PLAT_CODE_NONE  0x0 
  130. #define PLAT_CODE_WI2R  0x57693272  /* deprecated                         */ 
  131. #define PLAT_CODE_WI2K  0x5769326B  /* deprecated                         */ 
  132. #define PLAT_CODE_W2RU  0x57327275  /* Windows relative path (UTF-16)     */ 
  133. #define PLAT_CODE_W2KU  0x57326B75  /* Windows absolute path (UTF-16)     */ 
  134. #define PLAT_CODE_MAC   0x4D616320  /* MacOS alias stored as a blob.      */ 
  135. #define PLAT_CODE_MACX  0x4D616358  /* File URL (UTF-8), see RFC 2396.    */ 
  136.  
  137. /* ---------------------------------------------------------------------- */ 
  138. /* This is the dynamic disk header.                                       */ 
  139. /* ---------------------------------------------------------------------- */ 
  140.  
  141. struct dd_hdr { 
  142.   char   cookie[8];       /* Should contain "cxsparse"                    */ 
  143.   u64    data_offset;     /* Byte offset of next record. (Unused) 0xffs   */ 
  144.   u64    table_offset;    /* Absolute offset to the BAT.                  */ 
  145.   u32    hdr_ver;         /* Version of the dd_hdr (major,minor)          */ 
  146.   u32    max_bat_size;    /* Maximum number of entries in the BAT         */ 
  147.   u32    block_size;      /* Block size in bytes. Must be power of 2.     */ 
  148.   u32    checksum;        /* Header checksum.  1's comp of all fields.    */ 
  149.   vhd_uuid_t prt_uuid;    /* ID of the parent disk.                       */ 
  150.   u32    prt_ts;          /* Modification time of the parent disk         */ 
  151.   u32    res1;            /* Reserved.                                    */ 
  152.   char   prt_name[512];   /* Parent unicode name.                         */ 
  153.   struct prt_loc loc[8];  /* Parent locator entries.                      */ 
  154.   char   res2[256];       /* Reserved.                                    */ 
  155. }; 
  156.  
  157. /* VHD cookie string. */ 
  158. static const char DD_COOKIE[9]  =  "cxsparse"; 
  159.  
  160. /* Version field in hd_ftr */ 
  161. #define DD_VERSION 0x00010000 
  162.  
  163. /* Default blocksize is 2 meg. */ 
  164. #define DD_BLOCKSIZE_DEFAULT 0x00200000 
  165.  
  166. #define DD_BLK_UNUSED 0xFFFFFFFF 
  167.  
  168. struct dd_batmap_hdr { 
  169.   char   cookie[8];       /* should contain "tdbatmap"                    */ 
  170.   u64    batmap_offset;   /* byte offset to batmap                        */ 
  171.   u32    batmap_size;     /* batmap size in sectors                       */ 
  172.   u32    batmap_version;  /* version of batmap                            */ 
  173.   u32    checksum;        /* batmap checksum -- 1's complement of batmap  */ 
  174. }; 
  175.  
  176. static const char VHD_BATMAP_COOKIE[9] = "tdbatmap"; 
  177.  
  178. /* 
  179.  * version 1.1: signed char checksum 
  180.  */ 
  181. #define VHD_BATMAP_VERSION(major, minor)  (((major) << 16) | ((minor) & 0x0000FFFF)) 
  182. #define VHD_BATMAP_CURRENT_VERSION        VHD_BATMAP_VERSION(1, 2) 
  183.  
  184. /* Layout of a dynamic disk: 
  185.  * 
  186.  * +-------------------------------------------------+ 
  187.  * | Mirror image of HD footer (hd_ftr) (512 bytes)  | 
  188.  * +-------------------------------------------------+ 
  189.  * | Sparse drive header (dd_hdr) (1024 bytes)       | 
  190.  * +-------------------------------------------------+ 
  191.  * | BAT (Block allocation table)                    | 
  192.  * |   - Array of absolute sector offsets into the   | 
  193.  * |     file (u32).                                 | 
  194.  * |   - Rounded up to a sector boundary.            | 
  195.  * |   - Unused entries are marked as 0xFFFFFFFF     | 
  196.  * |   - max entries in dd_hdr->max_bat_size         | 
  197.  * +-------------------------------------------------+ 
  198.  * | Data Block 0                                    | 
  199.  * | Bitmap (padded to 512 byte sector boundary)     | 
  200.  * |   - each bit indicates whether the associated   | 
  201.  * |     sector within this block is used.           | 
  202.  * | Data                                            | 
  203.  * |   - power-of-two multiple of sectors.           | 
  204.  * |   - default 2MB (4096 * 512)                    | 
  205.  * |   - Any entries with zero in bitmap should be   | 
  206.  * |     zero on disk                                | 
  207.  * +-------------------------------------------------+ 
  208.  * | Data Block 1                                    | 
  209.  * +-------------------------------------------------+ 
  210.  * | ...                                             | 
  211.  * +-------------------------------------------------+ 
  212.  * | Data Block n                                    | 
  213.  * +-------------------------------------------------+ 
  214.  * | HD Footer (511 bytes)                           | 
  215.  * +-------------------------------------------------+ 
  216.  */ 
  217. #define LE32(x)  (( (u32)x >>24) ^ ((u32)x <<8 >>24 <<8) ^ ((u32)x <<16 >>24 <<16) ^ ((u32)x <<24)) 
  218. #define LE64(x)  (((u64)LE32((u32)x)) <<32 ) ^ ( LE32((u32)((u64)x >>32)) )  
  219.  
  220.  
  221. #endif 

 

本文出自 “张宇(数据恢复)” 博客，转载请与作者联系！

    相关新闻>>

    最新推荐更多>>>
    C++中实现Singlet
    C++中实现Singlet
    热门新闻进入编程开发频道>>
    C
    c语言课程设计网_学生成绩管理系统4
    C
    C语言课程设计报告_学生成绩简单管理程序
    C
    c语言课程设计_学生成绩管理系统1
    C
    学生成绩管理系统5_c语言课程设计
    C
    c语言课程设计_图书管理系统
    C
    c语言课程设计_学生成绩管理系统2
    发表评论
    请自觉遵守互联网相关的政策法规，严禁发布色情、暴力、反动的言论。
    用户名: 验证码:点击我更换图片
    最新评论 更多>>

    今日头条

    更多>>

    推荐热点

    • Glib实例学习（2）双链表
    • C程序员要学C++吗？
    • C++中实现Singleton的正确方法
    • 编程思维训练（一）
    • 【编程好习惯】引入中间变量使程序更易读
    • 在C++中通过模板规避潜在错误
    • 在C++中通过模板去除强制转换
    • 【编程好习惯】减少搜索头文件的目录数

    您可能感兴趣的文章

    快速直达

    新闻点评智问网络

    新闻关注排行榜

    热门推荐 最新推荐

    编程开发导航

    c#Cjava.net移动开发GO语言PerlPython
    网站首页 - 友情链接 - 网站地图 - TAG标签 - RSS订阅 - 内容搜索
    Copyright © 2008-2015 计算机技术学习交流网. 版权所有

    豫ICP备11007008号-1