Пример #1
0
//-----------------------------------------------------------------------------
bool copy_directory( std::string source_path, std::string target_path ) {
  boost::system::error_code ec;

  // get the directory
  if( !get_directory( target_path ) ) return false;

  // clean this directory, i.e. remove all children but not this directory
  if( !clean_directory( target_path ) ) return false;

  boost::filesystem::path src_path( source_path );
  boost::filesystem::path tgt_path( target_path );

  typedef std::vector<boost::filesystem::path> paths_t;
  paths_t src_paths;

  copy( boost::filesystem::directory_iterator( src_path ),
        boost::filesystem::directory_iterator(),
        back_inserter( src_paths ) );

  for( paths_t::const_iterator it = src_paths.begin(); it != src_paths.end(); it++ ) {

    boost::filesystem::path::iterator rel_path = --it->end();
    boost::filesystem::path next_src_path = *it;
    boost::filesystem::path next_tgt_path = tgt_path;
    next_tgt_path /= *rel_path;
    //std::cout << next_src_path << " -> " << next_tgt_path << '\n';
    
    if( boost::filesystem::is_directory( next_src_path, ec ) ) {
      // if it is a directory, recurse
      if( !copy_directory( next_src_path.string(), next_tgt_path.string() ) ) {
        return false;
      }
    } else {
      // otherwise, let boost handle the copy
      copy( next_src_path, next_tgt_path, ec );
      if( ec != boost::system::errc::success ) {
        std::cerr << ec.message() << std::endl;
        return false;
      }
    }
  }

  return true;
}
Пример #2
0
int main(int argc,char **argv) {
	struct libmsfat_disk_locations_and_info locinfo;
	struct libmsfat_file_io_ctx_t *fioctx_parent = NULL;
	struct libmsfat_file_io_ctx_t *fioctx = NULL;
	struct libmsfat_context_t *msfatctx = NULL;
	uint32_t first_lba=0,size_lba=0;
	const char *s_partition = NULL;
	libmsfat_FAT_entry_t fatent;
	uint32_t bytes_per_cluster;
	const char *s_image = NULL;
	libmsfat_cluster_t cluster;
	uint32_t zeroed_clusters=0;
	int i,fd;

	for (i=1;i < argc;) {
		const char *a = argv[i++];

		if (*a == '-') {
			do { a++; } while (*a == '-');

			if (!strcmp(a,"image")) {
				s_image = argv[i++];
			}
			else if (!strcmp(a,"partition")) {
				s_partition = argv[i++];
			}
			else if (!strcmp(a,"hole-punch")) {
				zero_by_holepunch = 1;
			}
			else {
				fprintf(stderr,"Unknown switch '%s'\n",a);
				return 1;
			}
		}
		else {
			fprintf(stderr,"Unexpected arg '%s'\n",a);
			return 1;
		}
	}

	if (libmsfat_sanity_check() != 0) {
		fprintf(stderr,"libmsfat sanity check fail\n");
		return 1;
	}

	if (s_image == NULL) {
		fprintf(stderr,"zerofree --image <image> ...\n");
		fprintf(stderr,"zero out all areas of the disk/partition that are not allocated by the filesystem.\n");
		fprintf(stderr,"\n");
		fprintf(stderr,"--partition <n>          Hard disk image, use partition N from the MBR\n");
		fprintf(stderr,"--hole-punch             Zero unused spaces by hole punching (making the file sparse).\n");
		fprintf(stderr,"                         This can allow zeroing the empty spaces a LOT faster, only if\n");
		fprintf(stderr,"                         supported by the filesystem.\n");
		return 1;
	}

	fd = open(s_image,O_RDWR|O_BINARY);
	if (fd < 0) {
		fprintf(stderr,"Unable to open disk image, %s\n",strerror(errno));
		return 1;
	}
	{
		/* make sure it's a file */
		_polyfill_struct_stat st;
		if (_polyfill_fstat(fd,&st) || (!S_ISREG(st.st_mode) && !S_ISBLK(st.st_mode))) {
			fprintf(stderr,"Image is not a file\n");
			return 1;
		}
	}

	if (s_partition != NULL) {
		struct libpartmbr_context_t *ctx = NULL;
		int index = atoi(s_partition);
		int dfd = -1;

		if (index < 0) {
			fprintf(stderr,"Invalid index\n");
			return 1;
		}

		ctx = libpartmbr_context_create();
		if (ctx == NULL) {
			fprintf(stderr,"Cannot allocate libpartmbr context\n");
			return 1;
		}

		/* good! hand it off to the context. use dup() because it takes ownership */
		dfd = dup(fd);
		if (libpartmbr_context_assign_fd(ctx,dfd)) {
			fprintf(stderr,"libpartmbr did not accept file descriptor %d\n",fd);
			close(dfd); // dispose of it
			return 1;
		}
		dfd = -1;
		ctx->geometry.cylinders = 16384;
		ctx->geometry.sectors = 63;
		ctx->geometry.heads = 255;

		/* load the partition table! */
		if (libpartmbr_context_read_partition_table(ctx)) {
			fprintf(stderr,"Failed to read partition table\n");
			return 1;
		}

		/* index */
		if ((size_t)index >= ctx->list_count) {
			fprintf(stderr,"Index too large\n");
			return 1;
		}

		/* valid? */
		struct libpartmbr_context_entry_t *ent = &ctx->list[(size_t)index];

		if (ent->is_empty) {
			fprintf(stderr,"You chose an empty MBR partition\n");
			return 1;
		}

		/* show */
		printf("Chosen partition:\n");
		printf("    Type: 0x%02x %s\n",
			(unsigned int)ent->entry.partition_type,
			libpartmbr_partition_type_to_str(ent->entry.partition_type));

		if (!(ent->entry.partition_type == LIBPARTMBR_TYPE_FAT12_32MB ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT16_32MB ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT16B_8GB ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT32_CHS ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT32_LBA ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT16B_LBA ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT12_32MB_HIDDEN ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT16_32MB_HIDDEN ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT16B_8GB_HIDDEN ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT32_CHS_HIDDEN ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT32_LBA_HIDDEN ||
			ent->entry.partition_type == LIBPARTMBR_TYPE_FAT16B_LBA_HIDDEN)) {
			fprintf(stderr,"MBR type does not suggest a FAT filesystem\n");
			return 1;
		}
		if (ent->entry.number_lba_sectors == (uint32_t)0) {
			fprintf(stderr,"Partition has no size\n");
			return 1;
		}
		first_lba = ent->entry.first_lba_sector;
		size_lba = ent->entry.number_lba_sectors;

		/* done */
		ctx = libpartmbr_context_destroy(ctx);
	}
	else {
		lseek_off_t x;

		first_lba = 0;

		x = _polyfill_lseek(fd,0,SEEK_END);
		if (x < (lseek_off_t)0) x = 0;
		x /= (lseek_off_t)512UL;
		if (x > (lseek_off_t)0xFFFFFFFFUL) x = (lseek_off_t)0xFFFFFFFFUL;
		size_lba = (uint32_t)x;
		_polyfill_lseek(fd,0,SEEK_SET);
	}

	printf("Reading from disk sectors %lu-%lu (%lu sectors)\n",
		(unsigned long)first_lba,
		(unsigned long)first_lba+(unsigned long)size_lba-(unsigned long)1UL,
		(unsigned long)size_lba);

	{
		lseek_off_t x = (lseek_off_t)first_lba * (lseek_off_t)512UL;

		if (_polyfill_lseek(fd,x,SEEK_SET) != x || read(fd,sectorbuf,512) != 512) {
			fprintf(stderr,"Unable to read boot sector\n");
			return 1;
		}
	}

	{
		const char *err_str = NULL;

		if (!libmsfat_boot_sector_is_valid(sectorbuf,&err_str)) {
			printf("Boot sector is not valid: reason=%s\n",err_str);
			return 1;
		}
	}

	{
		struct libmsfat_bootsector *p_bs = (struct libmsfat_bootsector*)sectorbuf;
		int dfd;

		if (libmsfat_bs_compute_disk_locations(&locinfo,p_bs)) {
			printf("Unable to locate disk locations.\n");
			return 1;
		}

		msfatctx = libmsfat_context_create();
		if (msfatctx == NULL) {
			fprintf(stderr,"Failed to create msfat context\n");
			return -1;
		}
		dfd = dup(fd);
		if (libmsfat_context_assign_fd(msfatctx,dfd)) {
			fprintf(stderr,"Failed to assign file descriptor to msfat\n");
			close(dfd);
			return -1;
		}
		dfd = -1; /* takes ownership, drop it */

		msfatctx->partition_byte_offset = (uint64_t)first_lba * (uint64_t)512UL;
		if (libmsfat_context_set_fat_info(msfatctx,&locinfo)) {
			fprintf(stderr,"msfat library rejected disk location info\n");
			return -1;
		}
	}

	fioctx_parent = libmsfat_file_io_ctx_create();
	if (fioctx_parent == NULL) {
		fprintf(stderr,"Cannot alloc FIO ctx\n");
		return 1;
	}

	fioctx = libmsfat_file_io_ctx_create();
	if (fioctx == NULL) {
		fprintf(stderr,"Cannot alloc FIO ctx\n");
		return 1;
	}

	printf("Scanning directory structure, to clean and repack diretories and zero file cluster tips\n");
	if (libmsfat_file_io_ctx_assign_root_directory_with_parent(fioctx,fioctx_parent,msfatctx) == 0)
		clean_directory(fioctx,fioctx_parent,msfatctx,NULL);
	else
		fprintf(stderr,"Unable to assign root directory\n");

	bytes_per_cluster = libmsfat_context_get_cluster_size(msfatctx);
	if (bytes_per_cluster == (uint32_t)0) {
		fprintf(stderr,"Unable to determine bytes per cluster\n");
		return 1;
	}

	printf("Scanning FAT table and zeroing unallocated clusters.\n");
	for (cluster=(libmsfat_cluster_t)2;cluster < msfatctx->fatinfo.Total_clusters;cluster++) {
		int percent;

		if (libmsfat_context_read_FAT(msfatctx,&fatent,cluster,0)) {
			fprintf(stderr,"\nERROR: unable to read FAT table entry #%lu\n",
				(unsigned long)cluster);
			continue;
		}

		if (msfatctx->fatinfo.FAT_size == 32)
			fatent &= libmsfat_FAT32_CLUSTER_MASK;

		percent = (int)(((uint64_t)cluster * (uint64_t)100UL) / msfatctx->fatinfo.Total_clusters);

		if (((uint32_t)cluster & 0xFF) == (uint32_t)0) {
			printf("\x0D" "Reading cluster %lu / %lu (%%%u) (%lu cleared) ",
				(unsigned long)cluster,
				(unsigned long)msfatctx->fatinfo.Total_clusters,
				percent,
				(unsigned long)zeroed_clusters);
			fflush(stdout);
		}

		if (fatent == (libmsfat_FAT_entry_t)0UL) {
			uint64_t offset;

			/* cluster is free! zero it! */
			if (libmsfat_context_get_cluster_offset(msfatctx,&offset,cluster)) {
				fprintf(stderr,"\nERROR: unable to locate cluster #%lu\n",
					(unsigned long)cluster);
				continue;
			}

			do_zero(msfatctx,offset,bytes_per_cluster);
			zeroed_clusters++;
		}
	}
	printf("\nDone!\n");

	/* this code focuses on FAT table #0. make sure to copy FAT 0 to FAT 1/2/3 etc. */
	for (i=1;i < (int)msfatctx->fatinfo.FAT_tables;i++) {
		if (libmsfat_context_copy_FAT(msfatctx,/*dst*/i,/*src*/0))
			fprintf(stderr,"Problem copying FAT table\n");
	}

	/* FAT32: Need to update free cluster count */
	if (msfatctx->fatinfo.FAT_size == 32) {
		if (libmsfat_context_update_fat32_free_cluster_count(msfatctx))
			fprintf(stderr,"Problem updating FSInfo free cluster count\n");
	}

	/* done */
	fioctx_parent = libmsfat_file_io_ctx_destroy(fioctx_parent);
	fioctx = libmsfat_file_io_ctx_destroy(fioctx);
	msfatctx = libmsfat_context_destroy(msfatctx);
	close(fd);
	fd = -1;
	return 0;
}
Пример #3
0
static void clean_directory(struct libmsfat_file_io_ctx_t *fioctx,struct libmsfat_file_io_ctx_t *fioctx_parent,struct libmsfat_context_t *msfatctx,struct libmsfat_dirent_t *dir_dirent) {
	struct libmsfat_dirent_t dirent;
	uint32_t last_ro_end=0;
	uint32_t truncate=0;
	uint32_t ro=0,wo=0;

	/* scan the directory. we need to recurse into subdirectories. */
	if (libmsfat_file_io_ctx_rewinddir(fioctx,msfatctx,NULL) == 0) {
		while (libmsfat_file_io_ctx_readdir(fioctx,msfatctx,NULL,&dirent) == 0) {
			struct libmsfat_file_io_ctx_t *subfioctx;

			if (dirent.a.n.DIR_Attr & libmsfat_DIR_ATTR_VOLUME_ID)
				continue;
			if ((dirent.a.n.DIR_Attr & libmsfat_DIR_ATTR_DIRECTORY) && libmsfat_dirent_is_dot_dir(&dirent))
				continue;

			subfioctx = libmsfat_file_io_ctx_create();
			if (subfioctx != NULL && libmsfat_file_io_ctx_assign_from_dirent(subfioctx,msfatctx,&dirent) == 0) {
				{
					char tmp[64];

					tmp[0] = 0; libmsfat_dirent_filename_to_str(tmp,sizeof(tmp),&dirent);
					printf("...cleaning ");
					if (dirent.a.n.DIR_Attr & libmsfat_DIR_ATTR_DIRECTORY)
						printf("subdirectory ");
					else
						printf("file cluster tip in ");

					printf("'%s'\n",tmp);
				}

				if (dirent.a.n.DIR_Attr & libmsfat_DIR_ATTR_DIRECTORY)
					clean_directory(subfioctx,fioctx,msfatctx,&dirent);
				else
					clean_file_cluster_tip(subfioctx,fioctx,msfatctx,&dirent);

				subfioctx = libmsfat_file_io_ctx_destroy(subfioctx);
			}
		}
	}

	/* scan the directory again, copying items back to fill in deleted and empty entries */
	while (1) {
		if (libmsfat_file_io_ctx_lseek(fioctx,msfatctx,ro,/*flags*/0))
			break;
		if (libmsfat_file_io_ctx_tell(fioctx,msfatctx) != ro)
			break;
		if (libmsfat_file_io_ctx_read(fioctx,msfatctx,&dirent,sizeof(dirent)) != sizeof(dirent))
			break;

		/* skip empty/deleted dirent entries */
		if (dirent.a.n.DIR_Name[0] == 0x00 || dirent.a.n.DIR_Name[0] == (char)0xE5) {
			ro += (uint32_t)sizeof(dirent);
			continue;
		}

		/* if ro != wo, move the dirent back */
		if (ro != wo) {
			if (libmsfat_file_io_ctx_lseek(fioctx,msfatctx,wo,/*flags*/0))
				break;
			if (libmsfat_file_io_ctx_tell(fioctx,msfatctx) != wo)
				break;
			if (libmsfat_file_io_ctx_write(fioctx,msfatctx,&dirent,sizeof(dirent)) != sizeof(dirent))
				break;
		}

		ro += (uint32_t)sizeof(dirent);
		wo += (uint32_t)sizeof(dirent);
		last_ro_end = ro;
	}

	/* if we removed anything, say so (NTS: the above code should always cause wo < ro) */
	if (last_ro_end != wo)
		printf("Removed %lu empty/deleted directory entries\n",
			((unsigned long)(last_ro_end-wo)) / (unsigned long)sizeof(dirent));

	/* take note where the write pointer is. we will truncate there after zeroing the directory.
	 * but, do not truncate the directory to zero! it is not specified in Microsoft's standards
	 * document whether an empty directory is given at minimum one cluster, or whether it is not
	 * given any clusters and the starting cluster is zero (like a file). to be safe, we do not
	 * allow truncating to zero. */
	truncate = wo;
	if (truncate == (uint32_t)0) truncate = (uint32_t)sizeof(dirent);

	/* fill out the rest of the directory with zeros */
	memset(&dirent,0,sizeof(dirent));
	if (libmsfat_file_io_ctx_lseek(fioctx,msfatctx,wo,/*flags*/0))
		return;
	if (libmsfat_file_io_ctx_tell(fioctx,msfatctx) != wo)
		return;
	while (libmsfat_file_io_ctx_write(fioctx,msfatctx,&dirent,sizeof(dirent)) == sizeof(dirent))
		{ };

	/* truncate, if possible (if the directory is based on a cluster chain) */
	if (fioctx->is_cluster_chain) {
		if (libmsfat_file_io_ctx_truncate_file(fioctx,fioctx_parent,msfatctx,dir_dirent,NULL,truncate))
			fprintf(stderr,"ERROR: failed to truncate directory (truncate point=%lu first_cluster=%lu)\n",
				(unsigned long)truncate,
				(unsigned long)fioctx->first_cluster);
	}
}