/** * Returns true iff the car at rel_x, rel_y with orientation "rotation" is * overlapping the base car. rel_x, rel_y and rotation are all relative * to the base car. It is assumed that base car is "chasing" the other, * hence rotation is within + or - 90 degrees and rel_y is greater than 0. * Both cars are rectangles of length CARLEN and width CARWID, and rel_x * and rel_y refer to the center points of the rectangles. * * @param rel_x (in) relative position x * @param rel_y (in) relative position y * @param rotation (in) relative angle * @return 0 if not in 1 if collision */ int collide(double rel_x, double rel_y, double rotation) { double x, y; double sine, cosine; // sine and cosine of the relative rotation sine = sin(rotation); cosine = cos(rotation); if(other_in(rel_x, rel_y, sine, cosine)) { return 1; } else { x = rel_x * cosine + rel_y * sine; y = rel_y * cosine - rel_x * sine; if(other_in(x, y, -sine, cosine)) { return 1; } else { return 0; } } }
DLLEXPORT void LoadActions(IServer* pServer) { Server=pServer; std::string compress_file = Server->getServerParameter("compress"); if(!compress_file.empty()) { IFile* in = Server->openFile(compress_file, MODE_READ_SEQUENTIAL); if(in==NULL) { Server->Log("Cannot open file \""+compress_file+"\" to compress", LL_ERROR); exit(1); } { Server->deleteFile(compress_file+".urz"); CompressedFile compFile(compress_file+".urz", MODE_RW_CREATE); if(compFile.hasError()) { Server->Log("Error opening compressed file", LL_ERROR); exit(3); } char buffer[32768]; _u32 read; do { read = in->Read(buffer, 32768); if(read>0) { if(compFile.Write(buffer, read)!=read) { Server->Log("Error writing to compressed file", LL_ERROR); exit(2); } } } while (read>0); compFile.finish(); delete in; } exit(0); } std::string decompress = Server->getServerParameter("decompress"); if(!decompress.empty()) { bool selected_via_gui=false; #ifdef _WIN32 if(decompress=="SelectViaGUI") { std::string filter; filter += "Compressed image files (*.vhdz)"; filter += '\0'; filter += "*.vhdz"; filter += '\0'; filter += '\0'; std::vector<std::string> res = file_via_dialog("Please select compressed image file to decompress", filter, false, true, ""); if(!res.empty()) { decompress = res[0]; } else { decompress.clear(); } if(decompress.empty()) { exit(1); } else { selected_via_gui=true; } } #endif std::string targetName = decompress; if(findextension(decompress)!="vhdz" && findextension(decompress)!="urz") { Server->Log("Unknown file extension: "+findextension(decompress), LL_ERROR); exit(1); } if(!Server->getServerParameter("output_fn").empty() && !selected_via_gui) { targetName = Server->getServerParameter("output_fn"); } bool b = decompress_vhd(decompress, targetName); exit(b?0:3); } std::string assemble = Server->getServerParameter("assemble"); if(!assemble.empty()) { bool selected_via_gui=false; std::vector<std::string> input_files; std::string output_file; #ifdef _WIN32 if(assemble=="SelectViaGUI") { std::string filter; filter += "Image files (*.vhdz;*.vhd)"; filter += '\0'; filter += "*.vhdz;*.vhd"; filter += '\0'; /*filter += L"Image files (*.vhd)"; filter += '\0'; filter += L"*.vhd"; filter += '\0';*/ filter += '\0'; std::vector<std::string> new_input_files; do { new_input_files = file_via_dialog("Please select all the images to assemble into one image. Cancel once finished.", filter, true, true, ""); input_files.insert(input_files.end(), new_input_files.begin(), new_input_files.end()); } while (!new_input_files.empty()); filter.clear(); filter += "Image file (*.vhd)"; filter += '\0'; filter += "*.vhd"; filter += '\0'; filter += '\0'; std::vector<std::string> output_files = file_via_dialog("Please select where to save the output image", filter, false, false, "vhd"); if(!output_files.empty()) { output_file = output_files[0]; } selected_via_gui=true; } #endif if(!selected_via_gui) { Tokenize(assemble, input_files, ";"); output_file = Server->getServerParameter("output_file"); } if(input_files.empty()) { Server->Log("No input files selected", LL_ERROR); exit(1); } if(output_file.empty()) { Server->Log("No output file selected", LL_ERROR); exit(1); } bool b = assemble_vhd(input_files, output_file); exit(b?0:3); } std::string devinfo=Server->getServerParameter("devinfo"); if(!devinfo.empty()) { FSNTFS ntfs("\\\\.\\"+devinfo+":", IFSImageFactory::EReadaheadMode_None, false, NULL); if(!ntfs.hasError()) { Server->Log("Used Space: "+convert(ntfs.calculateUsedSpace())+" of "+convert(ntfs.getSize())); Server->Log(convert(((float)ntfs.calculateUsedSpace()/(float)ntfs.getSize())*100.0f)+" %"); } } std::string vhdcopy_in=Server->getServerParameter("vhdcopy_in"); if(!vhdcopy_in.empty()) { Server->Log("VHDCopy."); VHDFile in(vhdcopy_in, true,0); if(in.isOpen()==false) { Server->Log("Error opening VHD-File \""+vhdcopy_in+"\"", LL_ERROR); exit(4); } uint64 vhdsize=in.getSize(); float vhdsize_gb=(vhdsize/1024)/1024.f/1024.f; uint64 vhdsize_mb=vhdsize/1024/1024; Server->Log("VHD Info: Size: "+convert(vhdsize_gb)+" GB "+convert(vhdsize_mb)+" MB",LL_INFO); unsigned int vhd_blocksize=in.getBlocksize(); std::string vhdcopy_out=Server->getServerParameter("vhdcopy_out"); if(vhdcopy_out.empty()) { Server->Log("'vhdcopy_out' not specified. Not copying.", LL_ERROR); exit(5); } else { IFile *out=Server->openFile(vhdcopy_out, MODE_RW); if(out==NULL) { Server->Log("Couldn't open output file", LL_ERROR); exit(6); } else { std::string skip_s=Server->getServerParameter("skip"); int skip=1024*512; if(!skip_s.empty()) { skip=atoi(skip_s.c_str()); } else if (is_disk_mbr(vhdcopy_in + ".mbr")) { skip = 0; } Server->Log("Skipping "+convert(skip)+" bytes...", LL_INFO); in.Seek(skip); char buffer[4096]; size_t read; int last_pc=0; int p_skip=0; uint64 currpos=skip; bool is_ok=true; out->Seek(0); while(currpos%vhd_blocksize!=0) { is_ok=in.Read(buffer, 512, read); if(read>0) { _u32 rc=out->Write(buffer, (_u32)read); if(rc!=read) { Server->Log("Writing to output file failed", LL_ERROR); exit(7); } } currpos+=read; } if(currpos!=skip) { Server->Log("First VHD sector at "+convert(currpos), LL_INFO); } do { if(in.has_sector()) { is_ok=in.Read(buffer, 4096, read); if(read>0) { _u32 rc=out->Write(buffer, (_u32)read); if(rc!=read) { Server->Log("Writing to output file failed", LL_ERROR); exit(7); } } currpos+=read; } else { read=4096; currpos+=read; in.Seek(currpos); out->Seek(currpos-skip); } ++p_skip; if(p_skip>100) { p_skip=0; int pc=(int)(((float)currpos/(float)vhdsize)*100.f+0.5f); if(pc!=last_pc) { Server->Log(convert(pc)+"%", LL_INFO); last_pc=pc; } } } while( read==4096 && is_ok ); Server->destroy(out); Server->Log("Copy process finished successfully.", LL_INFO); exit(0); } } } std::string hashfilecomp_1=Server->getServerParameter("hashfilecomp_1"); if(!hashfilecomp_1.empty()) { IFile *hf1=Server->openFile(hashfilecomp_1, MODE_READ); IFile *hf2=Server->openFile(Server->getServerParameter("hashfilecomp_2"), MODE_READ); if(hf1==NULL || hf2==NULL ) { Server->Log("Error opening hashfile", LL_ERROR); } else { size_t h_equal=0; size_t h_diff=0; _i64 fsize=hf1->Size(); for(_i64 p=0;p<fsize;p+=32) { char buf1[32]; hf1->Read(buf1, 32); char buf2[32]; hf2->Read(buf2, 32); if( memcmp(buf1, buf2, 32)==0) { ++h_equal; } else { ++h_diff; } } std::cout << "Hashfile analysis: " << h_equal << " equal hashes; " << h_diff << " differences " << std::endl; } exit(5); } std::string vhdinfo=Server->getServerParameter("vhdinfo"); if(!vhdinfo.empty()) { std::cout << "--VHDINFO--" << std::endl; VHDFile in(vhdinfo, true,0); if(in.isOpen()==false) { Server->Log("Error opening VHD-File \""+vhdinfo+"\"", LL_ERROR); exit(4); } uint64 vhdsize=in.getSize(); float vhdsize_gb=(vhdsize/1024)/1024.f/1024.f; uint64 vhdsize_mb=vhdsize/1024/1024; std::cout << ("VHD Info: Size: "+convert(vhdsize_gb)+" GB "+convert(vhdsize_mb)+" MB") << std::endl; std::cout << "Blocksize: " << in.getBlocksize() << " Bytes" << std::endl; uint64 new_blocks=0; uint64 total_blocks=0; unsigned int bs=in.getBlocksize(); for(uint64 pos=0;pos<vhdsize;pos+=bs) { in.Seek(pos); if(in.this_has_sector()) { ++new_blocks; } ++total_blocks; } std::cout << "Blocks: " << new_blocks << "/" << total_blocks << std::endl; exit(3); } std::string image_verify=Server->getServerParameter("image_verify"); if(!image_verify.empty()) { std::auto_ptr<IVHDFile> in(open_device_file(image_verify)); if(in.get()==NULL || in->isOpen()==false) { Server->Log("Error opening Image-File \""+image_verify+"\"", LL_ERROR); exit(4); } std::string s_hashfile=Server->getServerParameter("hashfile"); bool has_hashfile=true; if(s_hashfile.empty()) { has_hashfile=false; s_hashfile=image_verify+".hash"; } IFile *hashfile=Server->openFile(s_hashfile, MODE_READ); if(hashfile==NULL) { Server->Log("Error opening hashfile"); exit(5); } bool verify_all = Server->getServerParameter("verify_all")=="true"; if(verify_all) { Server->Log("Verifying empty blocks"); } const int64 vhd_blocksize=(1024*1024)/2; int skip=1024*512; std::string s_verify_skip = Server->getServerParameter("verify_skip"); if (!s_verify_skip.empty()) { skip = watoi(s_verify_skip); } in->Seek(skip); uint64 currpos=skip; uint64 size=in->getSize(); sha256_ctx ctx; sha256_init(&ctx); char buf[512]; int diff=0; int diff_w=0; size_t ok_blocks=0; int last_pc=0; unsigned char dig_z[32]; bool has_dig_z=false; for(;currpos<size;currpos+=vhd_blocksize) { in->Seek(currpos); bool has_sector=verify_all || in->this_has_sector(vhd_blocksize); if(!has_sector && !has_dig_z) { for(unsigned int i=0;i<vhd_blocksize;i+=512) { size_t read; in->Read(buf, 512, read); sha256_update(&ctx, (unsigned char*)buf, 512); } sha256_final(&ctx, dig_z); sha256_init(&ctx); has_dig_z=true; } unsigned char dig_r[32]; unsigned char dig_f[32]; if(has_sector) { for(unsigned int i=0;i<vhd_blocksize && currpos+i<size;i+=512) { size_t read; in->Read(buf, 512, read); sha256_update(&ctx, (unsigned char*)buf, 512); } _u32 dr=hashfile->Read((char*)dig_f, 32); if( dr!=32 ) { Server->Log("Could not read hash from file", LL_ERROR); } sha256_final(&ctx, dig_r); sha256_init(&ctx); } else { hashfile->Read((char*)dig_f, 32); memcpy(dig_r, dig_z, 32); } if(memcmp(dig_r, dig_f, 32)!=0) { ++diff; Server->Log("Different blocks: "+convert(diff)+" at pos "+convert(currpos)+" has_sector="+convert(has_sector)); } else if(has_sector && has_hashfile) { ++diff_w; Server->Log("Wrong difference: "+convert(diff_w)+" at pos "+convert(currpos)); } else { ++ok_blocks; } int pc=(int)((float)((float)currpos/(float)size)*100.f+0.5f); if(pc!=last_pc) { last_pc=pc; Server->Log("Checking hashfile: "+convert(pc)+"%"); } } if(diff==0) { Server->Log("Hashfile does match"); } Server->Log("Blocks with correct hash: "+convert(ok_blocks)); Server->Log("Different blocks: "+convert(diff)); Server->Log("Wrong differences: "+convert(diff_w)); exit(diff==0?0:7); } std::string device_verify=Server->getServerParameter("device_verify"); if(!device_verify.empty()) { std::auto_ptr<IVHDFile> in(open_device_file(device_verify)); if(in.get()==NULL || in->isOpen()==false) { Server->Log("Error opening Image-File \""+device_verify+"\"", LL_ERROR); exit(4); } int skip=1024*512; FileWrapper wrapper(in.get(), skip); FSNTFS fs(&wrapper, IFSImageFactory::EReadaheadMode_None, false, NULL); if(fs.hasError()) { Server->Log("Error opening device file", LL_ERROR); exit(3); } PrintInfo(&fs); std::string s_hashfile=Server->getServerParameter("hash_file"); if(s_hashfile.empty()) { s_hashfile = device_verify+".hash"; } IFile *hashfile=Server->openFile(s_hashfile, MODE_READ); if(hashfile==NULL) { Server->Log("Error opening hashfile "+s_hashfile); exit(7); } unsigned int ntfs_blocksize=(unsigned int)fs.getBlocksize(); unsigned int vhd_sectorsize=(1024*1024)/2; uint64 currpos=0; uint64 size=fs.getSize(); sha256_ctx ctx; sha256_init(&ctx); int diff=0; int last_pc=0; int mixed=0; std::vector<char> zerobuf; zerobuf.resize(ntfs_blocksize); memset(&zerobuf[0], 0, ntfs_blocksize); for(;currpos<size;currpos+=ntfs_blocksize) { bool has_block=fs.hasBlock(currpos/ntfs_blocksize); if(has_block) { fs_buffer buf(&fs, fs.readBlock(currpos/ntfs_blocksize)); if(buf.get()==NULL) { Server->Log("Could not read block "+convert(currpos/ntfs_blocksize), LL_ERROR); } else { sha256_update(&ctx, (unsigned char*)buf.get(), ntfs_blocksize); } mixed = mixed | 1; } else { sha256_update(&ctx, (unsigned char*)&zerobuf[0], ntfs_blocksize); mixed = mixed | 2; } if( (currpos+ntfs_blocksize)%vhd_sectorsize==0 ) { unsigned char dig_r[32]; unsigned char dig_f[32]; _u32 dr=hashfile->Read((char*)dig_f, 32); if( dr!=32 ) { Server->Log("Could not read hash from file", LL_ERROR); } sha256_final(&ctx, dig_r); sha256_init(&ctx); if(memcmp(dig_r, dig_f, 32)!=0 && mixed!=2) { ++diff; Server->Log("Different blocks: "+convert(diff)+" at pos "+convert(currpos)+" mixed = "+ (mixed==3? "true":"false")+" ("+convert(mixed)+")" ); } mixed=0; } int pc=(int)((float)((float)currpos/(float)size)*100.f+0.5f); if(pc!=last_pc) { last_pc=pc; Server->Log("Checking device hashsums: "+convert(pc)+"%"); } } if(diff>0) { Server->Log("Device does not match hash file"); } Server->Log("Different blocks: "+convert(diff)); exit(7); } std::string vhd_cmp=Server->getServerParameter("vhd_cmp"); if(!vhd_cmp.empty()) { VHDFile in(vhd_cmp, true,0); if(in.isOpen()==false) { Server->Log("Error opening VHD-File \""+vhd_cmp+"\"", LL_ERROR); exit(4); } std::string other=Server->getServerParameter("other"); VHDFile other_in(other, true,0); if(other_in.isOpen()==false) { Server->Log("Error opening VHD-File \""+other+"\"", LL_ERROR); exit(4); } unsigned int blocksize=in.getBlocksize(); int skip=1024*512; in.Seek(skip); other_in.Seek(skip); uint64 currpos=skip; uint64 size=(std::min)(in.getSize(), other_in.getSize()); char buf1[512]; char buf2[512]; int diff=0; int last_pc=0; for(;currpos<size;currpos+=blocksize) { in.Seek(currpos); other_in.Seek(currpos); bool has_sector=in.this_has_sector() || other_in.this_has_sector(); if(in.this_has_sector() && !other_in.this_has_sector()) { Server->Log("Sector only in file 1 at pos "+convert(currpos)); } if(!in.this_has_sector() && other_in.this_has_sector()) { Server->Log("Sector only in file 2 at pos "+convert(currpos)); } if(has_sector) { bool hdiff=false; for(unsigned int i=0;i<blocksize;i+=512) { size_t read; in.Read(buf1, 512, read); other_in.Read(buf2, 512, read); int mr=memcmp(buf1, buf2, 512); if(mr!=0) { int n=0; for(size_t i=0;i<512;++i) { if(buf1[i]!=buf2[i]) { ++n; } } if(n==2) { NTFSFileRecord *fr=(NTFSFileRecord*)buf1; if(fr->magic[0]=='F' && fr->magic[1]=='I' && fr->magic[2]=='L' && fr->magic[3]=='E' ) { MFTAttribute attr; attr.length=fr->attribute_offset; int pos=0; do { pos+=attr.length; memcpy((char*)&attr, buf1+pos, sizeof(MFTAttribute) ); if(attr.type==0x30 && attr.nonresident==0) //FILENAME { MFTAttributeFilename fn; memcpy((char*)&fn, buf1+pos+attr.attribute_offset, sizeof(MFTAttributeFilename) ); std::string fn_uc; fn_uc.resize(fn.filename_length*2); memcpy(&fn_uc[0], buf1+pos+attr.attribute_offset+sizeof(MFTAttributeFilename), fn.filename_length*2); Server->Log("Filename="+Server->ConvertFromUTF16(fn_uc) , LL_DEBUG); } Server->Log("Attribute Type: "+convert(attr.type)+" nonresident="+convert(attr.nonresident)+" length="+convert(attr.length), LL_DEBUG); }while( attr.type!=0xFFFFFFFF && attr.type!=0x80); } for(size_t i=0;i<512;++i) { if(buf1[i]!=buf2[i]) { Server->Log("Position "+convert(i)+": "+convert((int)buf1[i])+"<->"+convert((int)buf2[i])); } } } hdiff=true; break; } } if(hdiff) { ++diff; Server->Log("Different blocks: "+convert(diff)+" at pos "+convert(currpos)); } } int pc=(int)((float)((float)currpos/(float)size)*100.f+0.5f); if(pc!=last_pc) { last_pc=pc; Server->Log("Checking hashfile: "+convert(pc)+"%"); } } Server->Log("Different blocks: "+convert(diff)); exit(7); } std::string vhd_fixmftmirr=Server->getServerParameter("vhd_checkmftmirr"); if(!vhd_fixmftmirr.empty()) { VHDFile vhd(vhd_fixmftmirr, false, 0); vhd.addVolumeOffset(1024*512); if(vhd.isOpen()==false) { Server->Log("Could not open VHD file", LL_ERROR); exit(7); } if(Server->getServerParameter("fix")!="true") { FSNTFS fs(&vhd, IFSImageFactory::EReadaheadMode_None, false, NULL); if(fs.hasError()) { Server->Log("NTFS filesystem has errors", LL_ERROR); } exit(7); } else { FSNTFS fs(&vhd, IFSImageFactory::EReadaheadMode_None, false, NULL); if(fs.hasError()) { Server->Log("NTFS filesystem has errors", LL_ERROR); } exit(7); } exit(0); } #ifdef _DEBUG std::string fibmap_test_fn = Server->getServerParameter("fibmap_test"); if (!fibmap_test_fn.empty()) { #ifdef __linux__ fibmap_test(fibmap_test_fn, Server->getServerParameter("bitmap_source")); #endif exit(0); } #endif imagepluginmgr=new CImagePluginMgr; Server->RegisterPluginThreadsafeModel( imagepluginmgr, "fsimageplugin"); #ifndef STATIC_PLUGIN Server->Log("Loaded -fsimageplugin- plugin", LL_INFO); #endif }