protected void DoTests(FileHeader header, FileType expectedFileType, string expectedExtension) { string fileTypeErrorMessage; switch (expectedFileType) { default: case FileType.Other: fileTypeErrorMessage = "Unknown file type"; break; case FileType.Image: fileTypeErrorMessage = "Should be an image file"; break; case FileType.Video: fileTypeErrorMessage = "Should be a video file"; break; case FileType.Audio: fileTypeErrorMessage = "Should be an audio file"; break; case FileType.Swf: fileTypeErrorMessage = "Should be a flash file"; break; } var extensionErrorMessage = "File format should be " + expectedExtension; Assert.NotNull(header, "File header returned null"); Assert.AreEqual(header.Type, expectedFileType, fileTypeErrorMessage); Assert.AreEqual(header.Extension, expectedExtension, extensionErrorMessage); }
protected StorageStream(ITransactionalStorage transactionalStorage, string fileName, StorageStreamAccess storageStreamAccess, RavenJObject metadata, IndexStorage indexStorage, StorageOperationsTask operations) { TransactionalStorage = transactionalStorage; StorageStreamAccess = storageStreamAccess; Name = fileName; switch (storageStreamAccess) { case StorageStreamAccess.Read: TransactionalStorage.Batch(accessor => fileHeader = accessor.ReadFile(fileName)); if (fileHeader.TotalSize == null) { throw new FileNotFoundException("File is not uploaded yet"); } Metadata = fileHeader.Metadata; Seek(0, SeekOrigin.Begin); break; case StorageStreamAccess.CreateAndWrite: TransactionalStorage.Batch(accessor => { operations.IndicateFileToDelete(fileName); accessor.PutFile(fileName, null, metadata); indexStorage.Index(fileName, metadata); }); Metadata = metadata; break; default: throw new ArgumentOutOfRangeException("storageStreamAccess", storageStreamAccess, "Unknown value"); } }
public ConflictResolutionStrategy ConflictDetected(FileHeader local, FileHeader remote, string sourceServerUri) { if (local.LastModified.CompareTo(remote.LastModified) >= 0) return ConflictResolutionStrategy.CurrentVersion; else return ConflictResolutionStrategy.RemoteVersion; }
public PakElement(PakFile Owner, FileHeader Header, ExtendedFileStream Stream) { this.Owner = Owner; this.Id = Owner.GetId(); this.Stream = Stream; this.Header = Header; GetExtention(); }
public DownloadFile( FileHeader fileHeader, IServerConnection serverConnection, IEventAggregator eventAggregator) { _fileHeader = fileHeader; _serverConnection = serverConnection; _eventAggregator = eventAggregator; }
public void DeList() { if (_Elements.Count > 0) return; Decoded = false; Extractor.Instance.Progress(0); if (Headers == null) { Headers = new PakHeaders(); Headers.FileName = FileName; Headers.One = Stream.GetInt(); Headers.FileSize = Stream.GetInt(); Headers.Padding = Stream.GetInt(); Headers.Hsize = Stream.GetInt(); Headers.HeaderSize = Headers.Hsize / 60; for (int i = 0; i < Headers.HeaderSize; i++) { FileHeader Header = new FileHeader(); string Unk1 = Stream.GetString(20); Header.ZSize = Stream.GetInt(); Header.Size = Stream.GetInt(); Header.Unk2 = Stream.GetInt(); Header.Start = Stream.GetInt(); string Unk3 = Stream.GetString(24); Headers.Files.Add(Header); Extractor.Instance.Tool("Reading header :" + i + "/" + Headers.HeaderSize + ": " + Headers.FileName); Extractor.Instance.Progress((i * 100) / Headers.HeaderSize); } } int Total = Headers.Files.Count; for (int i = 0; i < Total; ++i) { Extractor.Instance.Progress((i * 100) / Total); FileHeader Header = Headers.Files[i]; PakElement Ep = new PakElement(this, Header, Stream); Ep.GetExtention(); _Elements.Add(Ep); } ExtractorMgr.SaveHeader(Headers); Extractor.Instance.Progress(100); Decoded = true; }
public void Constructor_Successful() { byte[] headerInfo = new byte[] { 0x00, 0x00, 0xE7, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE7, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; FileHeader fileHeader = new FileHeader(headerInfo); Assert.AreEqual(999, fileHeader.Size); Assert.AreEqual(999, fileHeader.PixelArrayOffset); }
public bool BeforeChange(FileHeader instance, RavenJObject metadata, RavenJObject original) { var tags = metadata.Value<RavenJArray>("Tags"); if (tags == null) return true; foreach (var banned in bannedTags) { tags.Remove(banned); } metadata["Tags"] = tags; return true; }
public bool Filter(FileHeader file, Guid destinationId, IEnumerable<FileHeader> candidatesToSynchronization) { // prevent synchronization back to source if (file.Metadata[SynchronizationConstants.RavenSynchronizationSource] == destinationId.ToString()) return false; if (file.Name.EndsWith(RavenFileNameHelper.DownloadingFileSuffix)) return false; if (file.Name.EndsWith(RavenFileNameHelper.DeletingFileSuffix)) return false; if (file.IsFileBeingUploadedOrUploadHasBeenBroken()) return false; if (ExistsRenameTombstone(file.Name, candidatesToSynchronization)) return false; return true; }
public void Load(byte[] DataArray) { Data = DataArray; Header = new FileHeader(Data); UInt32 ReadOffset = Header.VertexOffset; for (int i = 0; i < Header.VertexCount; i++) Vertices.Add(new Vertex(Data, ref ReadOffset)); ReadOffset = Header.TriangleOffset; for (int i = 0; i < Header.TriangleCount; i++) Triangles.Add(new Triangle(Data, ref ReadOffset)); ReadOffset = Header.TypeOffset; for (int i = 0; i < Header.TypeCount; i++) Types.Add(new Type(Data, ref ReadOffset)); Root.Nodes.Add(Helpers.CreateTreeNode(Name, this, string.Format("Size: {0:X6}", Data.Length))); Prepare(); }
public HttpResponseMessage Delete(string fileSystemName, string fileName) { var canonicalFilename = FileHeader.Canonize(fileName); var sourceServerInfo = InnerHeaders.Value <ServerInfo>(SyncingMultipartConstants.SourceServerInfo); var sourceFileETag = Guid.Parse(InnerHeaders.GetValues(Constants.MetadataEtagField).First().Trim('\"')); Log.Debug("Starting to delete a file '{0}' with ETag {1} from {2} because of synchronization", fileName, sourceFileETag, sourceServerInfo); var report = new SynchronizationReport(canonicalFilename, sourceFileETag, SynchronizationType.Delete); try { Storage.Batch(accessor => { AssertFileIsNotBeingSynced(canonicalFilename, accessor); FileLockManager.LockByCreatingSyncConfiguration(canonicalFilename, sourceServerInfo, accessor); }); SynchronizationTask.IncomingSynchronizationStarted(canonicalFilename, sourceServerInfo, sourceFileETag, SynchronizationType.Delete); PublishSynchronizationNotification(fileSystemName, canonicalFilename, sourceServerInfo, report.Type, SynchronizationAction.Start); Storage.Batch(accessor => StartupProceed(canonicalFilename, accessor)); var localMetadata = GetLocalMetadata(canonicalFilename); if (localMetadata != null) { // REVIEW: Use InnerHeaders for consistency? var sourceMetadata = GetFilteredMetadataFromHeaders(Request.Headers); // Request.Headers.FilterHeadersToObject(); bool isConflictResolved; AssertConflictDetection(canonicalFilename, localMetadata, sourceMetadata, sourceServerInfo, out isConflictResolved); Storage.Batch(accessor => { StorageOperationsTask.IndicateFileToDelete(canonicalFilename); var tombstoneMetadata = new RavenJObject { { SynchronizationConstants.RavenSynchronizationHistory, localMetadata[SynchronizationConstants.RavenSynchronizationHistory] }, { SynchronizationConstants.RavenSynchronizationVersion, localMetadata[SynchronizationConstants.RavenSynchronizationVersion] }, { SynchronizationConstants.RavenSynchronizationSource, localMetadata[SynchronizationConstants.RavenSynchronizationSource] } }.WithDeleteMarker(); Historian.UpdateLastModified(tombstoneMetadata); accessor.PutFile(canonicalFilename, 0, tombstoneMetadata, true); }); PublishFileNotification(fileName, FileChangeAction.Delete); } } catch (Exception ex) { if (ShouldAddExceptionToReport(ex)) { report.Exception = ex; Log.WarnException(string.Format("Error was occurred during deletion synchronization of file '{0}' from {1}", fileName, sourceServerInfo), ex); } } finally { FinishSynchronization(canonicalFilename, report, sourceServerInfo, sourceFileETag); } PublishSynchronizationNotification(fileSystemName, fileName, sourceServerInfo, report.Type, SynchronizationAction.Finish); if (report.Exception == null) { Log.Debug("File '{0}' was deleted during synchronization from {1}", fileName, sourceServerInfo); } return(this.GetMessageWithObject(report, HttpStatusCode.OK)); }
/// <summary> /// Decompress ZIP file /// </summary> /// <param name="fileHeader">The fh.</param> /// <param name="rootPathName">Name of the root path, save the decompressed file in this directory.</param> /// <param name="newFileName">New name of the file, if this file name is given it overwrite the name in the FH structure</param> /// <param name="createPath">if set to <c>true</c> [create path].</param> /// <param name="overWrite">if set to <c>true</c> [over write].</param> /// <exception cref="UZipDotNet.Exception"> /// Extract file failed. Invalid directory path /// or /// Unsupported compression method /// or /// ZIP file CRC test failed /// </exception> public void Decompress(FileHeader fileHeader, string rootPathName, string newFileName, bool createPath, bool overWrite) { try { // save file header _fileHeaderInfo = fileHeader; // read file header for this file and compare it to the directory information ReadFileHeader(_fileHeaderInfo.FilePos); // compressed length _readRemain = _fileHeaderInfo.CompSize; ReadTotal = _readRemain; // build write file name // Root name (optional) plus either original name or a new name _writeFileName = (string.IsNullOrEmpty(rootPathName) ? string.Empty : (rootPathName.EndsWith("\\") ? rootPathName : rootPathName + "\\")) + (string.IsNullOrEmpty(newFileName) ? fileHeader.FileName : newFileName); // test if write file name has a path component int ptr = _writeFileName.LastIndexOf('\\'); if (ptr >= 0) { // make sure directory exists if (!Directory.Exists(_writeFileName.Substring(0, ptr))) { // make a new folder if (createPath) Directory.CreateDirectory(_writeFileName.Substring(0, ptr)); // error else throw new Exception("Extract file failed. Invalid directory path"); } } // create destination file _writeStream = new FileStream(_writeFileName, overWrite ? FileMode.Create : FileMode.CreateNew, FileAccess.Write, FileShare.None); // convert stream to binary writer _writeFile = new BinaryWriter(_writeStream, Encoding.UTF8); // reset crc32 checksum _writeCrc32 = 0; // switch based on compression method switch (_fileHeaderInfo.CompMethod) { // no compression case 0: NoCompression(); break; // deflate compress method case 8: // decompress file Decompress(); break; // not supported default: throw new Exception("Unsupported compression method"); } // Zip file checksum is CRC32 if (_fileHeaderInfo.FileCRC32 != _writeCrc32) throw new Exception("ZIP file CRC test failed"); // save file length WriteTotal = (uint)_writeStream.Length; // close write file _writeFile.Close(); _writeFile = null; // if file times are available set the file time if (_fileTimeAvailable) { File.SetCreationTime(_writeFileName, _fileCreateTime); File.SetLastWriteTime(_writeFileName, _fileModifyTime); File.SetLastAccessTime(_writeFileName, _fileAccessTime); } else { // convert dos file date and time to DateTime format var fileDosTime = new DateTime(1980 + ((_fileHeaderInfo.FileDate >> 9) & 0x7f), (_fileHeaderInfo.FileDate >> 5) & 0xf, _fileHeaderInfo.FileDate & 0x1f, (_fileHeaderInfo.FileTime >> 11) & 0x1f, (_fileHeaderInfo.FileTime >> 5) & 0x3f, 2 * (_fileHeaderInfo.FileTime & 0x1f)); File.SetCreationTime(_writeFileName, fileDosTime); File.SetLastWriteTime(_writeFileName, fileDosTime); File.SetLastAccessTime(_writeFileName, fileDosTime); } // set file attribute attributes if (_fileHeaderInfo.FileAttr != 0) File.SetAttributes(_writeFileName, _fileHeaderInfo.FileAttr); } catch (Exception) { // close the write file if it is open if (_writeFile != null) { _writeFile.Close(); _writeFile = null; } throw; } }
internal override RarFilePart CreateFilePart(FileHeader fileHeader, MarkHeader markHeader) { return(new FileInfoRarFilePart(this, markHeader, fileHeader, FileInfo)); }
public async void Should_synchronize_to_all_destinations() { var canonicalFilename = FileHeader.Canonize("test.bin"); var sourceContent = SyncTestUtils.PrepareSourceStream(10000); sourceContent.Position = 0; var sourceClient = NewAsyncClient(0); var destination1Client = NewAsyncClient(1); var destination2Client = NewAsyncClient(2); var destination1Content = new RandomlyModifiedStream(sourceContent, 0.01); sourceContent.Position = 0; var destination2Content = new RandomlyModifiedStream(sourceContent, 0.01); sourceContent.Position = 0; await destination1Client.UploadAsync("test.bin", destination1Content); await destination2Client.UploadAsync("test.bin", destination2Content); sourceContent.Position = 0; await sourceClient.UploadAsync("test.bin", sourceContent); sourceContent.Position = 0; sourceClient.Synchronization.SetDestinationsAsync(destination1Client.ToSynchronizationDestination(), destination2Client.ToSynchronizationDestination()).Wait(); var destinationSyncResults = sourceClient.Synchronization.SynchronizeAsync().Result; // we expect conflicts after first attempt of synchronization Assert.Equal(2, destinationSyncResults.Length); Assert.Equal(string.Format("File {0} is conflicted", canonicalFilename), destinationSyncResults[0].Reports.ToArray()[0].Exception.Message); Assert.Equal(string.Format("File {0} is conflicted", canonicalFilename), destinationSyncResults[1].Reports.ToArray()[0].Exception.Message); await destination1Client.Synchronization.ResolveConflictAsync("test.bin", ConflictResolutionStrategy.RemoteVersion); await destination2Client.Synchronization.ResolveConflictAsync("test.bin", ConflictResolutionStrategy.RemoteVersion); destinationSyncResults = await sourceClient.Synchronization.SynchronizeAsync(); var conflictItem = await destination1Client.Configuration.GetKeyAsync <ConflictItem>(RavenFileNameHelper.ConflictConfigNameForFile("test.bin")); Assert.Null(conflictItem); conflictItem = await destination2Client.Configuration.GetKeyAsync <ConflictItem>(RavenFileNameHelper.ConflictConfigNameForFile("test.bin")); Assert.Null(conflictItem); // check if reports match Assert.Equal(2, destinationSyncResults.Length); var result1 = destinationSyncResults[0].Reports.ToArray()[0]; Assert.Equal(sourceContent.Length, result1.BytesCopied + result1.BytesTransfered); Assert.Equal(SynchronizationType.ContentUpdate, result1.Type); var result2 = destinationSyncResults[1].Reports.ToArray()[0]; Assert.Equal(sourceContent.Length, result2.BytesCopied + result2.BytesTransfered); Assert.Equal(SynchronizationType.ContentUpdate, result2.Type); // check content of files string destination1Md5; using (var resultFileContent = await destination1Client.DownloadAsync("test.bin")) { destination1Md5 = resultFileContent.GetMD5Hash(); } string destination2Md5; using (var resultFileContent = await destination2Client.DownloadAsync("test.bin")) { destination2Md5 = resultFileContent.GetMD5Hash(); } sourceContent.Position = 0; var sourceMd5 = sourceContent.GetMD5Hash(); Assert.Equal(sourceMd5, destination1Md5); Assert.Equal(sourceMd5, destination2Md5); Assert.Equal(destination1Md5, destination2Md5); }
public bool importFile(int fnum,bool isid,byte[] data) { DinnerEntry e = fileInfo(fnum, isid); FileHeader hdr = readHeader(fnum, isid); byte[] fl; if (e.compressed && hdr.compressed && hdr.tot_size != e.size) { UInt32 decompsz = (uint)data.Length; if (e.header) { hdr = new FileHeader(data); fl = data; data = new byte[fl.Length - FileHeader.size]; Array.Copy(fl, FileHeader.size,data,0, data.Length); hdr.setSize(decompsz); } else hdr.setSize(decompsz); byte[] cmpr = RNC.compress(data); data=new byte[cmpr.Length+FileHeader.size]; Array.Copy(hdr.buf, 0, data, 0, FileHeader.size); Array.Copy(cmpr, 0, data, FileHeader.size, cmpr.Length); } int resize = data.Length - (int)e.size; if (resize != 0) resizeDisk(resize,ref e); Array.Copy(data, 0, diskbuf, e.offset, data.Length); return true; }
public async Task NotificationsAreReceivedOnSourceWhenSynchronizationsAreStartedAndFinished() { // content update await sourceClient.UploadAsync("test.bin", new MemoryStream(new byte[] { 1, 2, 3 })); var notificationTask = sourceStore.Changes().ForSynchronization() .Where(s => s.Direction == SynchronizationDirection.Outgoing) .Timeout(TimeSpan.FromSeconds(20)).Take(2).ToArray(). ToTask(); var report = await sourceClient.Synchronization.StartAsync("test.bin", destinationClient); Assert.Null(report.Exception); var synchronizationUpdates = await notificationTask; Assert.Equal(SynchronizationAction.Start, synchronizationUpdates[0].Action); Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[0].FileName); Assert.Equal(SynchronizationType.ContentUpdate, synchronizationUpdates[0].Type); Assert.Equal(SynchronizationAction.Finish, synchronizationUpdates[1].Action); Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[1].FileName); Assert.Equal(SynchronizationType.ContentUpdate, synchronizationUpdates[1].Type); // metadata update await sourceClient.UpdateMetadataAsync("test.bin", new RavenJObject { { "key", "value" } }); notificationTask = sourceStore.Changes().ForSynchronization() .Where(s => s.Direction == SynchronizationDirection.Outgoing) .Timeout(TimeSpan.FromSeconds(20)) .Take(2).ToArray() .ToTask(); report = await sourceClient.Synchronization.StartAsync("test.bin", destinationClient); Assert.Null(report.Exception); synchronizationUpdates = await notificationTask; Assert.Equal(SynchronizationAction.Start, synchronizationUpdates[0].Action); Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[0].FileName); Assert.Equal(SynchronizationType.MetadataUpdate, synchronizationUpdates[0].Type); Assert.Equal(SynchronizationAction.Finish, synchronizationUpdates[1].Action); Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[1].FileName); Assert.Equal(SynchronizationType.MetadataUpdate, synchronizationUpdates[1].Type); // rename update await sourceClient.RenameAsync("test.bin", "rename.bin"); notificationTask = sourceStore.Changes().ForSynchronization() .Where(s => s.Direction == SynchronizationDirection.Outgoing) .Timeout(TimeSpan.FromSeconds(20)) .Take(2).ToArray() .ToTask(); report = await sourceClient.Synchronization.StartAsync("test.bin", destinationClient); Assert.Null(report.Exception); synchronizationUpdates = await notificationTask; Assert.Equal(SynchronizationAction.Start, synchronizationUpdates[0].Action); Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[0].FileName); Assert.Equal(SynchronizationType.Rename, synchronizationUpdates[0].Type); Assert.Equal(SynchronizationAction.Finish, synchronizationUpdates[1].Action); Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[1].FileName); Assert.Equal(SynchronizationType.Rename, synchronizationUpdates[1].Type); // delete update await sourceClient.DeleteAsync("rename.bin"); notificationTask = sourceStore.Changes().ForSynchronization() .Where(s => s.Direction == SynchronizationDirection.Outgoing) .Timeout(TimeSpan.FromSeconds(20)) .Take(2).ToArray() .ToTask(); report = await sourceClient.Synchronization.StartAsync("rename.bin", destinationClient); Assert.Null(report.Exception); synchronizationUpdates = await notificationTask; Assert.Equal(SynchronizationAction.Start, synchronizationUpdates[0].Action); Assert.Equal(FileHeader.Canonize("rename.bin"), synchronizationUpdates[0].FileName); Assert.Equal(SynchronizationType.Delete, synchronizationUpdates[0].Type); Assert.Equal(SynchronizationAction.Finish, synchronizationUpdates[1].Action); Assert.Equal(FileHeader.Canonize("rename.bin"), synchronizationUpdates[1].FileName); Assert.Equal(SynchronizationType.Delete, synchronizationUpdates[1].Type); }
public bool Read(string filename) { //try { m_Symbols = new List <SymbolEntry>(); m_Filenames = new List <FilenameSection>(); byte[] data = System.IO.File.ReadAllBytes(filename); if (data.Length > 0) { GCHandle pinnedData = GCHandle.Alloc(data, GCHandleType.Pinned); IntPtr stream = pinnedData.AddrOfPinnedObject(); FilenameHeader filenameHeader = new FilenameHeader(); ChunkHeader chunkHeader = new ChunkHeader(); FilenameSection filenameSection = new FilenameSection(); AddressEntry addressEntry = new AddressEntry(); SymbolChunk symbolChunk = new SymbolChunk(); SymbolEntry symbolEntry = new SymbolEntry(); string readString; int bytesRead = 0; // Symbol lines are 1-based, text editor lines are 0-based int currentLine = 1; //Read file header FileHeader fileHeader = new FileHeader(); bytesRead += Serialise(ref stream, out fileHeader); //Iterate over chunks while (bytesRead < data.Length) { //Read chunk header bytesRead += Serialise(ref stream, out chunkHeader); //What is it? switch (chunkHeader.chunkId) { case ChunkId.Filename: { //Read filename header bytesRead += Serialise(ref stream, out filenameHeader); filenameHeader.length = Endian.Swap(filenameHeader.length); //Read string bytesRead += Serialise(ref stream, filenameHeader.length, out readString); if (filenameHeader.flags == 0x1) { //This is the filename passed for assembly m_AssembledFile = readString; } else { //If filename already exists, continue adding data to it int sectionIdx = m_Filenames.FindIndex(element => element.filename == readString); if (sectionIdx >= 0) { //Continue filenameSection = m_Filenames[sectionIdx]; //Fetch line counter currentLine = filenameSection.addresses[filenameSection.addresses.Count - 1].lineTo; } else { //This is the first address in a filename chunk filenameSection = new FilenameSection(); filenameSection.addresses = new List <AddressEntry>(); filenameSection.filename = readString; //Reset line counter currentLine = 1; } //Chunk payload contains address addressEntry.address = chunkHeader.payload; addressEntry.lineFrom = currentLine - 1; addressEntry.lineTo = filenameHeader.firstLine - 1; currentLine = filenameHeader.firstLine; filenameSection.addresses.Add(addressEntry); //Next currentLine++; //Add to filename list m_Filenames.Add(filenameSection); } break; } case ChunkId.Address: { //Chunk payload contains address for a single line addressEntry.address = chunkHeader.payload; //Set line range addressEntry.lineFrom = currentLine - 1; addressEntry.lineTo = currentLine - 1; //Next currentLine++; //Add filenameSection.addresses.Add(addressEntry); break; } case ChunkId.AddressWithCount: { //Chunk payload contains address for a rage of lines addressEntry.address = chunkHeader.payload; //Read line count byte lineCount = 0; bytesRead += Serialise(ref stream, out lineCount); //Set line range addressEntry.lineFrom = currentLine - 1; addressEntry.lineTo = currentLine + (lineCount - 1) - 1; //Next currentLine += lineCount; //Add filenameSection.addresses.Add(addressEntry); break; } case ChunkId.Symbol: { //Read symbol string length byte stringLength = 0; bytesRead += Serialise(ref stream, out stringLength); //Read string bytesRead += Serialise(ref stream, stringLength, out symbolEntry.name); //Payload contains address symbolEntry.address = chunkHeader.payload; m_Symbols.Add(symbolEntry); break; } case ChunkId.EndOfSection: //Payload contains section size break; default: short mysteryWord = 0; bytesRead += Serialise(ref stream, out mysteryWord); break; } } pinnedData.Free(); //Build address to file/line map m_Addr2FileLine = new Dictionary <uint, Tuple <string, int, int> >(); foreach (FilenameSection section in m_Filenames) { foreach (AddressEntry address in section.addresses) { if (!m_Addr2FileLine.ContainsKey(address.address)) { m_Addr2FileLine[address.address] = new Tuple <string, int, int>(section.filename, address.lineFrom, address.lineTo); } } } return(true); } } //catch (Exception e) //{ // Console.WriteLine(e.Message); //} return(false); }
bool TryReadHeader(Stream stream, ref FileHeader fhdr, ref long dataStartOffset) { int numTracks = 82; stream.Seek(0, SeekOrigin.Begin); if (stream.Length < 16 + (2 * 82)) { return(false); } FileHeader fheader; /* assume it's a regular HD-Copy file without the disk name */ dataStartOffset = 2 + 2 * numTracks; fheader.lastCylinder = (byte)stream.ReadByte(); fheader.sectorsPerTrack = (byte)stream.ReadByte(); if (fheader.lastCylinder == 0xff && fheader.sectorsPerTrack == 0x18) { /* This is an "extended" HD-Copy file with filename information and 84 tracks */ stream.Seek(0x0e, SeekOrigin.Begin); fheader.lastCylinder = (byte)stream.ReadByte(); fheader.sectorsPerTrack = (byte)stream.ReadByte(); numTracks = 84; dataStartOffset = 16 + 2 * numTracks; } fheader.trackMap = new byte[2 * numTracks]; stream.Read(fheader.trackMap, 0, 2 * numTracks); /* Some sanity checks on the values we just read. * We know the image is from a DOS floppy disk, so assume * some sane cylinder and sectors-per-track count. */ if (fheader.sectorsPerTrack < 8 || fheader.sectorsPerTrack > 40) { return(false); } if (fheader.lastCylinder < 37 || fheader.lastCylinder >= 84) { return(false); } // Validate the trackmap. First two tracks need to be present if (fheader.trackMap[0] != 1 || fheader.trackMap[1] != 1) { return(false); } // all other tracks must be either present (=1) or absent (=0) for (int i = 0; i < 2 * numTracks; i++) { if (fheader.trackMap[i] > 1) { return(false); } } /* return success */ fhdr = fheader; return(true); }
void LoadDataFromDisk(PCFResourceType loadFlags, bool streamResources, bool assemblyMode) { Stream file = this.path.GetFileStream(FileMode.Open); //Load header first. this.fileHeader = LoadHeader(file); int bytesRead = HeaderByteLength; int fileLength = (int)file.Length; while (bytesRead < fileLength) { int chunkLength = GetNextSegmentLength(file); PCFBlockTypes blockType = GetNextBlockType(file); DataBlockBase block = null; PCFResourceType resourceType = PCFResourceType.NONE; if (blockType == PCFBlockTypes.INDEXBLOCK) { block = new IndexBlock(); this.blockData.Add(PCFResourceType.INDEX, block); } else if (blockType == PCFBlockTypes.NODEBLOCK) { block = new NodeBlock(loadFlags); this.blockData.Add(PCFResourceType.NODE, block); } else if (blockType == PCFBlockTypes.RESOURCEBLOCK) { //Read 4 bytes to determine resourcetype. file.Read(INT_BUFFER, 0, ChunkByteLength); int rawResourceTypeValue = BitConverter.ToInt32(INT_BUFFER, 0); resourceType = (PCFResourceType)Enum.ToObject(typeof(PCFResourceType), rawResourceTypeValue); //Allows us to mask what blocks to read in from file. if ((resourceType & loadFlags) != 0) { block = new ResourceBlock(resourceType, streamResources); this.blockData.Add(resourceType, block); } } else { Debug.LogError("Unknown block type"); } //Increment file position, make sure to count the chunk size bytes. bytesRead += chunkLength + ChunkByteLength; if (block != null) { if (memStream) { int bytsOffset = ChunkByteLength; if (blockType == PCFBlockTypes.RESOURCEBLOCK) { bytsOffset += ChunkByteLength; } long fileStreamPos = file.Position; byte[] streamBytes = new byte[chunkLength - bytsOffset]; file.Read(streamBytes, 0, chunkLength - bytsOffset); Stream stream = new MemoryStream(streamBytes); block.SetBytes(stream, chunkLength, fileStreamPos, assemblyMode); } else { //Will internally read from file and increment its position. block.SetBytes(file, chunkLength, 0, assemblyMode); } } else { //Manually seek to next chunk incase SetBytes was never called. file.Seek(bytesRead, SeekOrigin.Begin); } } if (file != null) { //Stop reading pcf file. file.Close(); } }
void SaveToDisk() { //Open file for reading. FileStream file = new FileStream(this.path.FullName, FileMode.Create, FileAccess.Write); FileHeader header = GetHeaderPrototype(); if (this.indexBlock == null) { Debug.LogError("No Index block specified!"); return; } int indexBlockSize = (this.blockData.Count * IndexBlock.BYTES_PER_ELEMENT) + ChunkByteLength + BlockTypeLength; //Calculate number of bytes to offset from start, make room for header and index block. int fileOffset = indexBlockSize + header.GetLength(); file.Seek((long)fileOffset, SeekOrigin.Begin); foreach (KeyValuePair <PCFResourceType, DataBlockBase> pair in this.blockData) { //Add index for each block. IndexElement indexElement = new IndexElement(pair.Key, fileOffset); this.indexBlock.AddIndex(indexElement); //All byte data for a block. byte[] blockData = pair.Value.GetBytes(); //Make sure we dont end up with empty blocks. if (blockData == null || blockData.Length == 0) { blockData = nullElement; } //Cannot use GetLength() here because we need to factor in all bytes including chunklength bytes. int blockLength = blockData.Length; file.Write(blockData, 0, blockLength); //Move file position to next block. fileOffset += blockLength; } header.SetFileLength(fileOffset - header.GetLength()); //Seek back to file header (aka index 0) and write header + index block to disk. file.Seek(0, SeekOrigin.Begin); byte[] headerBytes = header.GetBytes(); byte[] indexBytes = this.indexBlock.GetBytes(); file.Write(headerBytes, 0, headerBytes.Length); file.Write(indexBytes, 0, indexBytes.Length); if (file != null) { //Stop reading pcf file. file.Dispose(); file.Close(); } }
public async Task <HttpResponseMessage> MultipartProceed(string fileSystemName) { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var fileName = Request.Headers.GetValues(SyncingMultipartConstants.FileName).FirstOrDefault(); var canonicalFilename = FileHeader.Canonize(fileName); var tempFileName = RavenFileNameHelper.DownloadingFileName(canonicalFilename); var sourceServerInfo = InnerHeaders.Value <ServerInfo>(SyncingMultipartConstants.SourceServerInfo); var sourceFileETag = Guid.Parse(InnerHeaders.GetValues(Constants.MetadataEtagField).First().Trim('\"')); var report = new SynchronizationReport(canonicalFilename, sourceFileETag, SynchronizationType.ContentUpdate); Log.Debug("Starting to process multipart synchronization request of a file '{0}' with ETag {1} from {2}", fileName, sourceFileETag, sourceServerInfo); StorageStream localFile = null; var isNewFile = false; var isConflictResolved = false; try { Storage.Batch(accessor => { AssertFileIsNotBeingSynced(canonicalFilename, accessor); FileLockManager.LockByCreatingSyncConfiguration(canonicalFilename, sourceServerInfo, accessor); }); SynchronizationTask.IncomingSynchronizationStarted(canonicalFilename, sourceServerInfo, sourceFileETag, SynchronizationType.ContentUpdate); PublishSynchronizationNotification(fileSystemName, canonicalFilename, sourceServerInfo, report.Type, SynchronizationAction.Start); Storage.Batch(accessor => StartupProceed(canonicalFilename, accessor)); RavenJObject sourceMetadata = GetFilteredMetadataFromHeaders(InnerHeaders); var localMetadata = GetLocalMetadata(canonicalFilename); if (localMetadata != null) { AssertConflictDetection(canonicalFilename, localMetadata, sourceMetadata, sourceServerInfo, out isConflictResolved); localFile = StorageStream.Reading(Storage, canonicalFilename); } else { isNewFile = true; } Historian.UpdateLastModified(sourceMetadata); var synchronizingFile = SynchronizingFileStream.CreatingOrOpeningAndWriting(Storage, Search, StorageOperationsTask, tempFileName, sourceMetadata); var provider = new MultipartSyncStreamProvider(synchronizingFile, localFile); Log.Debug("Starting to process/read multipart content of a file '{0}'", fileName); await Request.Content.ReadAsMultipartAsync(provider); Log.Debug("Multipart content of a file '{0}' was processed/read", fileName); report.BytesCopied = provider.BytesCopied; report.BytesTransfered = provider.BytesTransfered; report.NeedListLength = provider.NumberOfFileParts; synchronizingFile.PreventUploadComplete = false; synchronizingFile.Flush(); synchronizingFile.Dispose(); sourceMetadata["Content-MD5"] = synchronizingFile.FileHash; Storage.Batch(accessor => accessor.UpdateFileMetadata(tempFileName, sourceMetadata)); Storage.Batch(accessor => { StorageOperationsTask.IndicateFileToDelete(canonicalFilename); accessor.RenameFile(tempFileName, canonicalFilename); Search.Delete(tempFileName); Search.Index(canonicalFilename, sourceMetadata); }); if (isNewFile) { Log.Debug("Temporary downloading file '{0}' was renamed to '{1}'. Indexes were updated.", tempFileName, fileName); } else { Log.Debug("Old file '{0}' was deleted. Indexes were updated.", fileName); } if (isConflictResolved) { ConflictArtifactManager.Delete(canonicalFilename); } } catch (Exception ex) { if (ShouldAddExceptionToReport(ex)) { report.Exception = ex; } } finally { if (localFile != null) { localFile.Dispose(); } } if (report.Exception == null) { Log.Debug( "File '{0}' was synchronized successfully from {1}. {2} bytes were transfered and {3} bytes copied. Need list length was {4}", fileName, sourceServerInfo, report.BytesTransfered, report.BytesCopied, report.NeedListLength); } else { Log.WarnException( string.Format("Error has occurred during synchronization of a file '{0}' from {1}", fileName, sourceServerInfo), report.Exception); } FinishSynchronization(canonicalFilename, report, sourceServerInfo, sourceFileETag); PublishFileNotification(fileName, isNewFile ? FileChangeAction.Add : FileChangeAction.Update); PublishSynchronizationNotification(fileSystemName, fileName, sourceServerInfo, report.Type, SynchronizationAction.Finish); if (isConflictResolved) { Publisher.Publish(new ConflictNotification { FileName = fileName, Status = ConflictStatus.Resolved }); } return(GetMessageWithObject(report)); }
internal NonSeekableStreamFilePart(MarkHeader mh, FileHeader fh) : base(mh, fh) { }
/// <summary> /// Read ZIP file directory /// </summary> /// <exception cref="UZipDotNet.Exception"> /// ZIP file is too short /// or /// Invalid ZIP file (No central directory) /// or /// No support for multi-disk ZIP file /// or /// Central directory is empty or in error /// or /// Central directory empty /// or /// File directory signature error /// or /// Directory name must have a slash /// </exception> private void ReadZipFileDirectory() { // End of central directory record: // Pos Len // 0 4 End of central directory signature = 0x06054b50 // 4 2 Number of this disk // 6 2 Disk where central directory starts // 8 2 Number of central directory records on this disk // 10 2 Total number of central directory records // 12 4 Size of central directory (bytes) // 16 4 Offset of start of central directory, relative to start of archive // 20 2 ZIP file comment length (n) // 22 n ZIP file comment // // Central directory file header // // Pos Len // 0 4 Central directory file header signature = 0x02014b50 // 4 2 Version made by // 6 2 Version needed to extract (minimum) // 8 2 General purpose bit flag // 10 2 Compression method // 12 2 File last modification time // 14 2 File last modification date // 16 4 CRC-32 // 20 4 Compressed size // 24 4 Uncompressed size // 28 2 File name length (n) // 30 2 Extra field length (m) // 32 2 File comment length (k) // 34 2 Disk number where file starts // 36 2 Internal file attributes // 38 4 External file attributes // 42 4 Offset of local file header // 46 n File name // 46+n m Extra field // 46+n+m k File comment // file length long fileLen = _writeStream.Length; if (fileLen < 98) throw new Exception("ZIP file is too short"); // read last 512 byte block at the end of the file if (fileLen > 512) _writeStream.Position = fileLen - 512; byte[] dirSig = _writeFileReader.ReadBytes(512); // look for signature int ptr; for (ptr = dirSig.Length - 20; ptr >= 0 && BitConverter.ToInt32(dirSig, ptr) != 0x06054b50; ptr--) { } if (ptr < 0) throw new Exception("Invalid ZIP file (No central directory)"); ptr += 4; // number of this disk should be zero short diskNo = BitConverter.ToInt16(dirSig, ptr); ptr += 2; if (diskNo != 0) throw new Exception("No support for multi-disk ZIP file"); // disk where central directory starts should be zero short dirDiskNo = BitConverter.ToInt16(dirSig, ptr); ptr += 2; if (dirDiskNo != 0) throw new Exception("No support for multi-disk ZIP file"); // Number of central directory records on this disk short dirEntries = BitConverter.ToInt16(dirSig, ptr); ptr += 2; // Total number of central directory records short dirEntriesTotal = BitConverter.ToInt16(dirSig, ptr); ptr += 2; if (dirEntriesTotal == 0 || dirEntriesTotal != dirEntries) throw new Exception("Central directory is empty or in error"); // Size of central directory (bytes) int dirSize = BitConverter.ToInt32(dirSig, ptr); ptr += 4; if (dirSize == 0) throw new Exception("Central directory empty"); // Offset of start of central directory, relative to start of archive _zipDirPosition = BitConverter.ToInt32(dirSig, ptr); if (_zipDirPosition == 0) throw new Exception("Central directory empty"); // create new zip directory array ZipDir = new List<FileHeader>(dirEntriesTotal); // position file to central directory _writeStream.Position = _zipDirPosition; // read central directory while (dirEntriesTotal-- > 0) { // file header var fh = new FileHeader(); // Central directory file header signature = 0x02014b50 int fileDirSig = _writeFileReader.ReadInt32(); if (fileDirSig != 0x02014b50) throw new Exception("File directory signature error"); // ReSharper disable once UnusedVariable : Version made by (ignored) //int versionMadeBy = _writeFileReader.ReadInt16(); // Low byte is version needed to extract (the low byte should be 20 for version 2.0). // High byte is a computer system code that define the extrenal file attribute. // If high byte is zero it is DOS compatible. fh.Version = _writeFileReader.ReadUInt16(); // General purpose bit flag (bit 0 encripted) fh.BitFlags = _writeFileReader.ReadUInt16(); // Compression method must be deflate or no compression fh.CompMethod = _writeFileReader.ReadUInt16(); // File last modification time fh.FileTime = _writeFileReader.ReadUInt16(); // File last modification date fh.FileDate = _writeFileReader.ReadUInt16(); // CRC-32 fh.FileCRC32 = _writeFileReader.ReadUInt32(); // Compressed size fh.CompSize = _writeFileReader.ReadUInt32(); // Uncompressed size fh.FileSize = _writeFileReader.ReadUInt32(); // File name length int fileNameLen = _writeFileReader.ReadInt16(); // Extra field length int extraFieldLen = _writeFileReader.ReadInt16(); // File comment length int commentLen = _writeFileReader.ReadInt16(); // Disk number where file starts int fileDiskNo = _writeFileReader.ReadInt16(); if (fileDiskNo != 0) throw new Exception("No support for multi-disk ZIP file"); // ReSharper disable once UnusedVariable : internal file attributes (ignored) //int fileIntAttr = _writeFileReader.ReadInt16(); // external file attributes fh.FileAttr = (FileAttributes)_writeFileReader.ReadUInt32(); // if file system is not FAT or equivalent, erase the attributes if ((fh.Version & 0xff00) != 0) fh.FileAttr = 0; // file position fh.FilePos = _writeFileReader.ReadUInt32(); // file name // read all the bytes of the file name into a byte array // extract a string from the byte array using DOS (IBM OEM code page 437) // replace the unix forward slash with microsoft back slash fh.FileName = Utils.DecodeFilename(_writeFileReader.ReadBytes(fileNameLen)); // if file attribute is a directory make sure we have terminating backslash // if((FH.FileAttr & FileAttributes.Directory) != 0 && !FH.FileName.EndsWith("\\")) FH.FileName += "\\"; // find if file name contains a path fh.Path = fh.FileName.Contains("\\"); // if we have a directory, we must have a terminating slash if ((fh.FileAttr & FileAttributes.Directory) != 0 && !fh.Path) throw new Exception("Directory name must have a slash"); // Skip Extra field and File comment _writeStream.Position += extraFieldLen + commentLen; // add file header to zip directory ZipDir.Add(fh); } // position file to central directory _writeStream.Position = _zipDirPosition; // remove central directory from this file _writeStream.SetLength(_zipDirPosition); // sort array ZipDir.Sort(); }
private static void ShapeFileHeaderWriter(ref System.IO.BinaryWriter bWriter, FileHeader SHPFileHeader) { bWriter.Write(SHPFileHeader.FileCode); bWriter.Write(SHPFileHeader.u1); bWriter.Write(SHPFileHeader.u2); bWriter.Write(SHPFileHeader.u3); bWriter.Write(SHPFileHeader.u4); bWriter.Write(SHPFileHeader.u5); bWriter.Write(SHPFileHeader.FileLength); bWriter.Write(SHPFileHeader.Version); bWriter.Write(SHPFileHeader.ShapeType); bWriter.Write(SHPFileHeader.BoundingBoxXMin); bWriter.Write(SHPFileHeader.BoundingBoxYMin); bWriter.Write(SHPFileHeader.BoundingBoxXMax); bWriter.Write(SHPFileHeader.BoundingBoxYMax); bWriter.Write(SHPFileHeader.BoundingBoxZMin); bWriter.Write(SHPFileHeader.BoundingBoxZMax); bWriter.Write(SHPFileHeader.BoundingBoxMMin); bWriter.Write(SHPFileHeader.BoundingBoxMMax); }
public HttpResponseMessage Get([FromUri] string[] fileNames) { var list = new List <FileHeader>(); var startsWith = GetQueryStringValue("startsWith"); if (string.IsNullOrEmpty(startsWith) == false) { var matches = GetQueryStringValue("matches"); var endsWithSlash = startsWith.EndsWith("/") || startsWith.EndsWith("\\"); startsWith = FileHeader.Canonize(startsWith); if (endsWithSlash) { startsWith += "/"; } Storage.Batch(accessor => { var actualStart = 0; var filesToSkip = Paging.Start; int fileCount, matchedFiles = 0, addedFiles = 0; do { fileCount = 0; foreach (var file in accessor.GetFilesStartingWith(startsWith, actualStart, Paging.PageSize)) { fileCount++; var keyTest = file.FullPath.Substring(startsWith.Length); if (WildcardMatcher.Matches(matches, keyTest) == false) { continue; } if (FileSystem.ReadTriggers.CanReadFile(FileHeader.Canonize(file.FullPath), file.Metadata, ReadOperation.Load) == false) { continue; } if (file.Metadata.Keys.Contains(SynchronizationConstants.RavenDeleteMarker)) { continue; } matchedFiles++; if (matchedFiles <= filesToSkip) { continue; } list.Add(file); addedFiles++; } actualStart += Paging.PageSize; }while (fileCount > 0 && addedFiles < Paging.PageSize && actualStart > 0 && actualStart < int.MaxValue); }); } else { if (fileNames != null && fileNames.Length > 0) { Storage.Batch(accessor => { foreach (var path in fileNames.Where(x => x != null).Select(FileHeader.Canonize)) { var file = accessor.ReadFile(path); if (file == null || file.Metadata.Keys.Contains(SynchronizationConstants.RavenDeleteMarker)) { list.Add(null); continue; } list.Add(file); } }); } else { int results; var keys = Search.Query(null, null, Paging.Start, Paging.PageSize, out results); Storage.Batch(accessor => list.AddRange(keys.Select(accessor.ReadFile).Where(x => x != null))); } } return(GetMessageWithObject(list) .WithNoCache()); }
//public static void CreateBlockFile(string sBlockId, string sBlockName, Hashtable Area_Shp, string DestFilePath, string DestFileName, ShapeType ShapeType) //{ // Hashtable Shp_Area = new Hashtable(); // //- Get Encoding used in Current CultureInfo of OS. // System.Text.Encoding FileEncoding = System.Text.Encoding.Default; // //*** Build ShapeFile - AreaId Collection with unique Shape and comma delimited Areaids // IDictionaryEnumerator dicEnumerator = Area_Shp.GetEnumerator(); // while (dicEnumerator.MoveNext()) // { // if (Shp_Area.ContainsKey(dicEnumerator.Value)) // { // Shp_Area[dicEnumerator.Value] = Shp_Area[dicEnumerator.Value].ToString() + "," + dicEnumerator.Key.ToString(); // } // else // { // Shp_Area.Add(dicEnumerator.Value, dicEnumerator.Key); // } // } // FileHeader SHPFileHeader = new FileHeader(); // FileStream oShpStream = new FileStream(DestFilePath + "\\" + DestFileName + ".shp", FileMode.Create); // BinaryWriter oShpBinaryWriter = new BinaryWriter(oShpStream); // FileStream oShxStream = new FileStream(DestFilePath + "\\" + DestFileName + ".shx", FileMode.Create); // BinaryWriter oShxBinaryWriter = new BinaryWriter(oShxStream); // FileStream oDbfStream = new FileStream(DestFilePath + "\\" + DestFileName + ".dbf", FileMode.Create); // BinaryWriter oDbfBinaryWriter = new BinaryWriter(oDbfStream, FileEncoding); // SHPFileHeader.FileCode = BigToLittleEndian(9994); // SHPFileHeader.Version = 1000; // SHPFileHeader.ShapeType = (int)ShapeType; // ShapeFileHeaderWriter(ref oShpBinaryWriter, SHPFileHeader); // //*** Write .Shp File Header // ShapeFileHeaderWriter(ref oShxBinaryWriter, SHPFileHeader); // //*** Write .Shx File Header // DbaseFileHeaderWriter(ref oDbfBinaryWriter, 1, FileEncoding); // //Area_Shp.Count '*** Write .dbf File Header // int i; // int j; // string[] AreaId; // string SrcFile; // string SrcFilePath; // string SrcFileName; // ShapeInfo ShpInfo; // Shape _Shape = new Shape(); // Shape _Block = new Shape(); // RectangleF _Extent = new RectangleF(); // PointF[] Pts; // int Offset = 50; // int RecordNumber; // int ContentLength; // int Points; // int BlockPointCount = 0; // int[] BlockPartOffset = null; // dicEnumerator = Shp_Area.GetEnumerator(); // while (dicEnumerator.MoveNext()) // { // SrcFile = dicEnumerator.Key.ToString(); // AreaId = dicEnumerator.Value.ToString().Split(","[0]); // if (File.Exists(SrcFile)) // { // SrcFilePath = Path.GetDirectoryName(SrcFile); // SrcFileName = Path.GetFileNameWithoutExtension(SrcFile); // ShpInfo = GetShapeInfo(SrcFilePath, SrcFileName); // switch (ShapeType) // { // case ShapeType.Point: // break; // case ShapeType.Polygon: // case ShapeType.PolyLine: // for (j = 0; j <= AreaId.Length - 1; j++) // { // if (ShpInfo.Records.ContainsKey(AreaId[j])) // { // _Shape = (Shape)ShpInfo.Records[AreaId[j]]; // if (_Extent.IsEmpty) // { // _Extent = _Shape.Extent; // } // else // { // _Extent = RectangleF.Union(_Extent, _Shape.Extent); // } // int iPrevPartsCount = _Block.Parts.Count; // //ReDim Preserve BlockPartOffset(iPrevPartsCount + _Shape.Parts.Count - 1) // //int[] YourArray; // //... // //int[] temp = new int[i + 1]; // //if (YourArray != null) // // Array.Copy(YourArray, temp, Math.Min(YourArray.Length, temp.Length)); // //YourArray = temp; // int[] temp = new int[iPrevPartsCount + _Shape.Parts.Count]; // if (BlockPartOffset != null) // Array.Copy(BlockPartOffset, temp, Math.Min(BlockPartOffset.Length, temp.Length)); // BlockPartOffset = temp; // Points = 0; // for (i = 0; i <= _Shape.Parts.Count - 1; i++) // { // Pts = (PointF[])_Shape.Parts[i]; // _Block.Parts.Add(Pts); // BlockPartOffset[iPrevPartsCount + i] = Pts.Length; // Points += Pts.Length; // BlockPointCount += Pts.Length; // } // } // } // break; // } // } // } // _Block.Extent = _Extent; // RecordNumber = 1; // //*** All Shape will be added as parts of a single block // ContentLength = ((11 + _Block.Parts.Count) * 2) + (BlockPointCount * 8); // PolygonRecordWriter(ref oShpBinaryWriter, RecordNumber, ContentLength, BlockPointCount, BlockPartOffset, _Block, SHPFileHeader.ShapeType); // IndexRecordWriter(ref oShxBinaryWriter, Offset, ContentLength); // //*** Write SHX Record // DbaseRecordWriter(ref oDbfBinaryWriter, sBlockId, sBlockName); // //*** Write DBF Record // if (ShapeType == ShapeType.Polygon | ShapeType == ShapeType.PolyLine) // { // SHPFileHeader.BoundingBoxXMin = _Extent.X; // SHPFileHeader.BoundingBoxYMin = _Extent.Y; // SHPFileHeader.BoundingBoxXMax = _Extent.X + _Extent.Width; // SHPFileHeader.BoundingBoxYMax = _Extent.Y + _Extent.Height; // } // //*** Reset FileLength and Extent in Shp File Header // oShpStream.Position = 24; // oShpBinaryWriter.Write(BigToLittleEndian((int)oShpStream.Length / 2)); // oShpStream.Position = 36; // oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxXMin); // oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxYMin); // oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxXMax); // oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxYMax); // //*** Reset FileLength and Extent in Shx File Header // oShxStream.Position = 24; // oShxBinaryWriter.Write(BigToLittleEndian((int)oShxStream.Length / 2)); // oShxStream.Position = 36; // oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxXMin); // oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxYMin); // oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxXMax); // oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxYMax); // //*** Dispose // oShpBinaryWriter.Close(); // oShxBinaryWriter.Close(); // oDbfBinaryWriter.Close(); // oShpStream.Close(); // oShxStream.Close(); // oDbfStream.Close(); // oShpBinaryWriter = null; // oShxBinaryWriter = null; // oDbfBinaryWriter = null; // // _Extent = null; // ShpInfo = null; //} ////*** Create Shape File for selected polygon from multiple shape file //[Obsolete] //public static void CreateShapeFile(Hashtable Area_Shp, string DestFilePath, string DestFileName, ShapeType ShapeType) //{ // Hashtable Shp_Area = new Hashtable(); // System.Text.Encoding FileEncoding = System.Text.Encoding.Default; // //*** Build ShapeFile - AreaId Collection with unique Shape and comma delimited Areaids // IDictionaryEnumerator dicEnumerator = Area_Shp.GetEnumerator(); // while (dicEnumerator.MoveNext()) // { // if (Shp_Area.ContainsKey(dicEnumerator.Value)) // { // Shp_Area[dicEnumerator.Value] = Shp_Area[dicEnumerator.Value].ToString() + "," + dicEnumerator.Key.ToString(); // } // else // { // Shp_Area.Add(dicEnumerator.Value, dicEnumerator.Key); // } // } // FileHeader SHPFileHeader = new FileHeader(); // FileStream oShpStream = new FileStream(DestFilePath + "\\" + DestFileName + ".shp", FileMode.Create); // BinaryWriter oShpBinaryWriter = new BinaryWriter(oShpStream); // FileStream oShxStream = new FileStream(DestFilePath + "\\" + DestFileName + ".shx", FileMode.Create); // BinaryWriter oShxBinaryWriter = new BinaryWriter(oShxStream); // FileStream oDbfStream = new FileStream(DestFilePath + "\\" + DestFileName + ".dbf", FileMode.Create); // BinaryWriter oDbfBinaryWriter = new BinaryWriter(oDbfStream, FileEncoding); // SHPFileHeader.FileCode = BigToLittleEndian(9994); // SHPFileHeader.Version = 1000; // SHPFileHeader.ShapeType = (int)ShapeType; // ShapeFileHeaderWriter(ref oShpBinaryWriter, SHPFileHeader); // //*** Write .Shp File Header // ShapeFileHeaderWriter(ref oShxBinaryWriter, SHPFileHeader); // //*** Write .Shx File Header // DbaseFileHeaderWriter(ref oDbfBinaryWriter, Area_Shp.Count, FileEncoding); // //*** Write .dbf File Header // int i; // int j; // string[] AreaId; // string SrcFile; // string SrcFilePath; // string SrcFileName; // ShapeInfo ShpInfo; // Shape _Shape = new Shape(); // RectangleF _Extent = new RectangleF(); // PointF[] Pts; // int Offset = 50; // int RecordNumber = 0; // int ContentLength; // int Points; // dicEnumerator = Shp_Area.GetEnumerator(); // while (dicEnumerator.MoveNext()) // { // SrcFile = dicEnumerator.Key.ToString(); // AreaId = dicEnumerator.Value.ToString().Split(","[0]); // if (File.Exists(SrcFile)) // { // SrcFilePath = Path.GetDirectoryName(SrcFile); // SrcFileName = Path.GetFileNameWithoutExtension(SrcFile); // ShpInfo = GetShapeInfo(SrcFilePath, SrcFileName); // switch (ShapeType) // { // case ShapeType.Point: // PointF Pt; // ContentLength = 10; // for (j = 0; j <= AreaId.Length - 1; j++) // { // if (ShpInfo.Records.ContainsKey(AreaId[j])) // { // _Shape = (Shape)ShpInfo.Records[AreaId[j]]; // Pt = (PointF)_Shape.Parts[0]; // if (RecordNumber == 0) // { // SHPFileHeader.BoundingBoxXMin = Pt.X; // SHPFileHeader.BoundingBoxYMin = Pt.Y; // SHPFileHeader.BoundingBoxXMax = Pt.X; // SHPFileHeader.BoundingBoxYMax = Pt.Y; // } // else // { // SHPFileHeader.BoundingBoxXMin = Math.Min(SHPFileHeader.BoundingBoxXMin, Pt.X); // SHPFileHeader.BoundingBoxYMin = Math.Min(SHPFileHeader.BoundingBoxYMin, Pt.Y); // SHPFileHeader.BoundingBoxXMax = Math.Max(SHPFileHeader.BoundingBoxXMax, Pt.X); // SHPFileHeader.BoundingBoxYMax = Math.Max(SHPFileHeader.BoundingBoxYMax, Pt.Y); // } // RecordNumber += 1; // oShpBinaryWriter.Write(BigToLittleEndian(RecordNumber)); // oShpBinaryWriter.Write(BigToLittleEndian(ContentLength)); // oShpBinaryWriter.Write((int)1); // //Shape Type // oShpBinaryWriter.Write((double)Pt.X); // oShpBinaryWriter.Write((double)Pt.Y); // IndexRecordWriter(ref oShxBinaryWriter, Offset, ContentLength); // //*** Write SHX Record // Offset += (4 + ContentLength); // //*** Add 4 for record header '*** Set Offset for next SHX record // DbaseRecordWriter(ref oDbfBinaryWriter, _Shape.AreaId, _Shape.AreaName); // //*** Write DBF Record // } // } // // Pt = null; // break; // case ShapeType.Polygon: // case ShapeType.PolyLine: // for (j = 0; j <= AreaId.Length - 1; j++) // { // if (ShpInfo.Records.ContainsKey(AreaId[j])) // { // _Shape = (Shape)ShpInfo.Records[AreaId[j]]; // if (_Extent.IsEmpty) // { // _Extent = _Shape.Extent; // } // else // { // _Extent = RectangleF.Union(_Extent, _Shape.Extent); // } // int[] NumPoints = new int[_Shape.Parts.Count]; // Points = 0; // for (i = 0; i <= _Shape.Parts.Count - 1; i++) // { // Pts = (PointF[])_Shape.Parts[i]; // NumPoints[i] = Pts.Length; // Points += Pts.Length; // } // ContentLength = ((11 + _Shape.Parts.Count) * 2) + (Points * 8); // RecordNumber += 1; // PolygonRecordWriter(ref oShpBinaryWriter, RecordNumber, ContentLength, Points, NumPoints, _Shape, SHPFileHeader.ShapeType); // IndexRecordWriter(ref oShxBinaryWriter, Offset, ContentLength); // //*** Write SHX Record // Offset += (4 + ContentLength); // //*** Add 4 for record header '*** Set Offset for next SHX record // DbaseRecordWriter(ref oDbfBinaryWriter, _Shape.AreaId, _Shape.AreaName); // //*** Write DBF Record // } // } // break; // } // } // } // if (ShapeType == ShapeType.Polygon | ShapeType == ShapeType.PolyLine) // { // SHPFileHeader.BoundingBoxXMin = _Extent.X; // SHPFileHeader.BoundingBoxYMin = _Extent.Y; // SHPFileHeader.BoundingBoxXMax = _Extent.X + _Extent.Width; // SHPFileHeader.BoundingBoxYMax = _Extent.Y + _Extent.Height; // } // //*** Reset FileLength and Extent in Shp File Header // oShpStream.Position = 24; // oShpBinaryWriter.Write(BigToLittleEndian((int)oShpStream.Length / 2)); // oShpStream.Position = 36; // oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxXMin); // oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxYMin); // oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxXMax); // oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxYMax); // //*** Reset FileLength and Extent in Shx File Header // oShxStream.Position = 24; // oShxBinaryWriter.Write(BigToLittleEndian((int)oShxStream.Length / 2)); // oShxStream.Position = 36; // oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxXMin); // oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxYMin); // oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxXMax); // oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxYMax); // //*** Dispose // oShpBinaryWriter.Close(); // oShxBinaryWriter.Close(); // oDbfBinaryWriter.Close(); // oShpStream.Close(); // oShxStream.Close(); // oDbfStream.Close(); // oShpBinaryWriter = null; // oShxBinaryWriter = null; // oDbfBinaryWriter = null; // // _Extent = null; // ShpInfo = null; //} //[Obsolete] //public static void CreateShapeFile(Hashtable Area_Shp, string DestFilePath, string DestFileName) //{ // ShapeType ShapeType = ShapeType.Polygon; // CreateShapeFile(Area_Shp, DestFilePath, DestFileName, ShapeType); //} //*** Create Shape File for selected polygon from single shape file - Used for Split process public static void CreateShapeFile(string AreaIds, string SrcFilePath, string SrcFileName, string DestFilePath, string DestFileName) { ShapeInfo ShpInfo = GetShapeInfo(SrcFilePath, SrcFileName); string[] AreaId; AreaId = AreaIds.Split(","[0]); FileHeader SHPFileHeader = new FileHeader(); FileStream oShpStream = new FileStream(DestFilePath + "\\" + DestFileName + ".shp", FileMode.Create); BinaryWriter oShpBinaryWriter = new BinaryWriter(oShpStream); FileStream oShxStream = new FileStream(DestFilePath + "\\" + DestFileName + ".shx", FileMode.Create); BinaryWriter oShxBinaryWriter = new BinaryWriter(oShxStream); FileStream oDbfStream = new FileStream(DestFilePath + "\\" + DestFileName + ".dbf", FileMode.Create); //- Get Encoding used in source Shape file (.dbf) System.Text.Encoding FileEncoding = ShapeFileReader.GetEncodingInDBF(SrcFilePath + "\\" + SrcFileName + ".dbf"); BinaryWriter oDbfBinaryWriter = new BinaryWriter(oDbfStream, FileEncoding); //System.Text.Encoding.ASCII SHPFileHeader.FileCode = BigToLittleEndian(9994); SHPFileHeader.Version = 1000; switch (ShpInfo.ShapeType) { case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.Point: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PointCustom: SHPFileHeader.ShapeType = (int)ShapeType.Point; break; case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolyLine: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolyLineCustom: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolyLineFeature: SHPFileHeader.ShapeType = (int)ShapeType.PolyLine; break; case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.Polygon: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolygonBuffer: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolygonCustom: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolygonFeature: SHPFileHeader.ShapeType = (int)ShapeType.Polygon; break; } ShapeFileHeaderWriter(ref oShpBinaryWriter, SHPFileHeader); //*** Write .Shp File Header ShapeFileHeaderWriter(ref oShxBinaryWriter, SHPFileHeader); //*** Write .Shx File Header DbaseFileHeaderWriter(ref oDbfBinaryWriter, AreaId.Length, FileEncoding); //*** Write .dbf File Header int i; int j; Shape _Shape = new Shape(); PointF[] Pts; int Offset = 50; int RecordNumber = 0; int ContentLength; int Points; switch (SHPFileHeader.ShapeType) { case 1: PointF Pt; ContentLength = 10; for (j = 0; j <= AreaId.Length - 1; j++) { if (ShpInfo.Records.ContainsKey(AreaId[j])) { _Shape = (Shape)ShpInfo.Records[AreaId[j]]; Pt = (PointF)_Shape.Parts[0]; if (j == 0) { SHPFileHeader.BoundingBoxXMin = Pt.X; SHPFileHeader.BoundingBoxYMin = Pt.Y; SHPFileHeader.BoundingBoxXMax = Pt.X; SHPFileHeader.BoundingBoxYMax = Pt.Y; } else { SHPFileHeader.BoundingBoxXMin = Math.Min(SHPFileHeader.BoundingBoxXMin, Pt.X); SHPFileHeader.BoundingBoxYMin = Math.Min(SHPFileHeader.BoundingBoxYMin, Pt.Y); SHPFileHeader.BoundingBoxXMax = Math.Max(SHPFileHeader.BoundingBoxXMax, Pt.X); SHPFileHeader.BoundingBoxYMax = Math.Max(SHPFileHeader.BoundingBoxYMax, Pt.Y); } RecordNumber += 1; oShpBinaryWriter.Write(BigToLittleEndian(RecordNumber)); oShpBinaryWriter.Write(BigToLittleEndian(ContentLength)); oShpBinaryWriter.Write((int)1); //Shape Type oShpBinaryWriter.Write((double)Pt.X); oShpBinaryWriter.Write((double)Pt.Y); IndexRecordWriter(ref oShxBinaryWriter, Offset, ContentLength); //*** Write SHX Record Offset += (4 + ContentLength); //*** Add 4 for record header '*** Set Offset for next SHX record DbaseRecordWriter(ref oDbfBinaryWriter, _Shape.AreaId, _Shape.AreaName); //*** Write DBF Record } } break; case 3: case 5: RectangleF _Extent = new RectangleF(); for (j = 0; j <= AreaId.Length - 1; j++) { if (ShpInfo.Records.ContainsKey(AreaId[j])) { _Shape = (Shape)ShpInfo.Records[AreaId[j]]; if (_Extent.IsEmpty) { _Extent = _Shape.Extent; } else { _Extent = RectangleF.Union(_Extent, _Shape.Extent); } int[] NumPoints = new int[_Shape.Parts.Count]; Points = 0; for (i = 0; i <= _Shape.Parts.Count - 1; i++) { Pts = (PointF[])_Shape.Parts[i]; NumPoints[i] = Pts.Length; Points += Pts.Length; } ContentLength = ((11 + _Shape.Parts.Count) * 2) + (Points * 8); RecordNumber += 1; PolygonRecordWriter(ref oShpBinaryWriter, RecordNumber, ContentLength, Points, NumPoints, _Shape, SHPFileHeader.ShapeType); IndexRecordWriter(ref oShxBinaryWriter, Offset, ContentLength); //*** Write SHX Record Offset += (4 + ContentLength); //*** Add 4 for record header '*** Set Offset for next SHX record DbaseRecordWriter(ref oDbfBinaryWriter, _Shape.AreaId, _Shape.AreaName); //*** Write DBF Record } } SHPFileHeader.BoundingBoxXMin = _Extent.X; SHPFileHeader.BoundingBoxYMin = _Extent.Y; SHPFileHeader.BoundingBoxXMax = _Extent.X + _Extent.Width; SHPFileHeader.BoundingBoxYMax = _Extent.Y + _Extent.Height; // _Extent = null; break; } //*** Reset FileLength and Extent in Shp File Header oShpStream.Position = 24; oShpBinaryWriter.Write(BigToLittleEndian((int)oShpStream.Length / 2)); oShpStream.Position = 36; oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxXMin); oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxYMin); oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxXMax); oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxYMax); //*** Reset FileLength and Extent in Shx File Header oShxStream.Position = 24; oShxBinaryWriter.Write(BigToLittleEndian((int)oShxStream.Length / 2)); oShxStream.Position = 36; oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxXMin); oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxYMin); oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxXMax); oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxYMax); //*** Dispose oShpBinaryWriter.Close(); oShxBinaryWriter.Close(); oDbfBinaryWriter.Close(); oShpStream.Close(); oShxStream.Close(); oDbfStream.Close(); oShpBinaryWriter = null; oShxBinaryWriter = null; oDbfBinaryWriter = null; ShpInfo = null; }
public bool importFile(int fnum,bool isid,byte[] data) { DinnerEntry e = fileInfo(fnum, isid); FileHeader hdr = readHeader(fnum, isid); byte[] fl; if (e.compressed && hdr.compressed && hdr.tot_size != e.size) { UInt32 decompsz = (uint)data.Length; if (e.header) { hdr = new FileHeader(data); fl = data; data = new byte[fl.Length - FileHeader.size]; Array.Copy(fl, FileHeader.size, data, 0, data.Length); hdr.setSize(decompsz); } else hdr.setSize(decompsz); byte[] cmpr = RNCCompressor.compress(data); data=new byte[cmpr.Length+FileHeader.size]; Array.Copy(hdr.buf, 0, data, 0, FileHeader.size); Array.Copy(cmpr, 0, data, FileHeader.size, cmpr.Length); } int resize = data.Length - (int)e.size; if (resize != 0) resizeDisk(resize,ref e); if (InstallPack) { FileStream f = new FileStream(Path.Combine(path,fnum.ToString()+".bin"), FileMode.Create); f.Write(data, 0, data.Length); f.Close(); } Array.Copy(data, 0, diskbuf, e.offset, data.Length); return true; }
public static void CreateBlockFile(string sBlockId, string sBlockName, Hashtable Area_Shp, string DestFilePath, string DestFileName, ShapeType ShapeType) { Hashtable Shp_Area = new Hashtable(); //- Get Encoding used in Current CultureInfo of OS. System.Text.Encoding FileEncoding = System.Text.Encoding.Default; //*** Build ShapeFile - AreaId Collection with unique Shape and comma delimited Areaids IDictionaryEnumerator dicEnumerator = Area_Shp.GetEnumerator(); while (dicEnumerator.MoveNext()) { if (Shp_Area.ContainsKey(dicEnumerator.Value)) { Shp_Area[dicEnumerator.Value] = Shp_Area[dicEnumerator.Value].ToString() + "," + dicEnumerator.Key.ToString(); } else { Shp_Area.Add(dicEnumerator.Value, dicEnumerator.Key); } } FileHeader SHPFileHeader = new FileHeader(); FileStream oShpStream = new FileStream(DestFilePath + "\\" + DestFileName + ".shp", FileMode.Create); BinaryWriter oShpBinaryWriter = new BinaryWriter(oShpStream); FileStream oShxStream = new FileStream(DestFilePath + "\\" + DestFileName + ".shx", FileMode.Create); BinaryWriter oShxBinaryWriter = new BinaryWriter(oShxStream); FileStream oDbfStream = new FileStream(DestFilePath + "\\" + DestFileName + ".dbf", FileMode.Create); BinaryWriter oDbfBinaryWriter = new BinaryWriter(oDbfStream, FileEncoding); SHPFileHeader.FileCode = BigToLittleEndian(9994); SHPFileHeader.Version = 1000; SHPFileHeader.ShapeType = (int)ShapeType; ShapeFileHeaderWriter(ref oShpBinaryWriter, SHPFileHeader); //*** Write .Shp File Header ShapeFileHeaderWriter(ref oShxBinaryWriter, SHPFileHeader); //*** Write .Shx File Header DbaseFileHeaderWriter(ref oDbfBinaryWriter, 1, FileEncoding); //Area_Shp.Count '*** Write .dbf File Header int i; int j; string[] AreaId; string SrcFile; string SrcFilePath; string SrcFileName; ShapeInfo ShpInfo; Shape _Shape = new Shape(); Shape _Block = new Shape(); RectangleF _Extent = new RectangleF(); PointF[] Pts; int Offset = 50; int RecordNumber; int ContentLength; int Points; int BlockPointCount = 0; int[] BlockPartOffset = null; // Iterate for all distinct shape files to // set single composite multipart polygon containing all distinct shapes in refrred shapefiles // set composite extent dicEnumerator = Shp_Area.GetEnumerator(); while (dicEnumerator.MoveNext()) { SrcFile = dicEnumerator.Key.ToString(); AreaId = dicEnumerator.Value.ToString().Split(","[0]); if (File.Exists(SrcFile)) { SrcFilePath = Path.GetDirectoryName(SrcFile); SrcFileName = Path.GetFileNameWithoutExtension(SrcFile); ShpInfo = GetShapeInfo(SrcFilePath, SrcFileName); switch (ShapeType) { case ShapeType.Point: //TODO break; case ShapeType.Polygon: case ShapeType.PolyLine: // Iterate for each shape IDictionaryEnumerator dicShapeEnumerator = ShpInfo.Records.GetEnumerator(); while (dicShapeEnumerator.MoveNext()) { _Shape = (Shape)dicShapeEnumerator.Value; if (_Extent.IsEmpty) { _Extent = _Shape.Extent; } else { _Extent = RectangleF.Union(_Extent, _Shape.Extent); } int iPrevPartsCount = _Block.Parts.Count; int[] temp = new int[iPrevPartsCount + _Shape.Parts.Count]; if (BlockPartOffset != null) Array.Copy(BlockPartOffset, temp, Math.Min(BlockPartOffset.Length, temp.Length)); BlockPartOffset = temp; Points = 0; // Iterate for each part for (i = 0; i <= _Shape.Parts.Count - 1; i++) { Pts = (PointF[])_Shape.Parts[i]; _Block.Parts.Add(Pts); BlockPartOffset[iPrevPartsCount + i] = Pts.Length; Points += Pts.Length; BlockPointCount += Pts.Length; } } break; } } } _Block.Extent = _Extent; RecordNumber = 1; //*** All Shape will be added as parts of a single block ContentLength = ((11 + _Block.Parts.Count) * 2) + (BlockPointCount * 8); PolygonRecordWriter(ref oShpBinaryWriter, RecordNumber, ContentLength, BlockPointCount, BlockPartOffset, _Block, SHPFileHeader.ShapeType); IndexRecordWriter(ref oShxBinaryWriter, Offset, ContentLength); //*** Write SHX Record DbaseRecordWriter(ref oDbfBinaryWriter, sBlockId, sBlockName); //*** Write DBF Record if (ShapeType == ShapeType.Polygon | ShapeType == ShapeType.PolyLine) { SHPFileHeader.BoundingBoxXMin = _Extent.X; SHPFileHeader.BoundingBoxYMin = _Extent.Y; SHPFileHeader.BoundingBoxXMax = _Extent.X + _Extent.Width; SHPFileHeader.BoundingBoxYMax = _Extent.Y + _Extent.Height; } //*** Reset FileLength and Extent in Shp File Header oShpStream.Position = 24; oShpBinaryWriter.Write(BigToLittleEndian((int)oShpStream.Length / 2)); oShpStream.Position = 36; oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxXMin); oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxYMin); oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxXMax); oShpBinaryWriter.Write(SHPFileHeader.BoundingBoxYMax); //*** Reset FileLength and Extent in Shx File Header oShxStream.Position = 24; oShxBinaryWriter.Write(BigToLittleEndian((int)oShxStream.Length / 2)); oShxStream.Position = 36; oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxXMin); oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxYMin); oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxXMax); oShxBinaryWriter.Write(SHPFileHeader.BoundingBoxYMax); //*** Dispose oShpBinaryWriter.Close(); oShxBinaryWriter.Close(); oDbfBinaryWriter.Close(); oShpStream.Close(); oShxStream.Close(); oDbfStream.Close(); oShpBinaryWriter = null; oShxBinaryWriter = null; oDbfBinaryWriter = null; // _Extent = null; ShpInfo = null; }
FileHeader GetHeaderPrototype() { FileHeader header = new FileHeader(FileVersion, 0, this.fileType); return(header); }
public static void CreateShapefile(Layer _Layer, string FilePath, string FileName) { System.Text.Encoding FileEncoding = System.Text.Encoding.Default; FileHeader SHPFileHeader = new FileHeader(); FileStream oShpStream = new FileStream(FilePath + "\\" + FileName + ".shp", FileMode.Create); BinaryWriter oShpBinaryWriter = new BinaryWriter(oShpStream); FileStream oShxStream = new FileStream(FilePath + "\\" + FileName + ".shx", FileMode.Create); BinaryWriter oShxBinaryWriter = new BinaryWriter(oShxStream); FileStream oDbfStream = new FileStream(FilePath + "\\" + FileName + ".dbf", FileMode.Create); BinaryWriter oDbfBinaryWriter = new BinaryWriter(oDbfStream, FileEncoding); SHPFileHeader.FileCode = BigToLittleEndian(9994); SHPFileHeader.Version = 1000; switch (_Layer.LayerType) { case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.Point: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PointCustom: SHPFileHeader.ShapeType = (int)ShapeType.Point; break; case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolyLine: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolyLineCustom: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolyLineFeature: SHPFileHeader.ShapeType = (int)ShapeType.PolyLine; break; case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.Polygon: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolygonBuffer: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolygonCustom: case DevInfo.Lib.DI_LibBAL.UI.Presentations.Map.ShapeType.PolygonFeature: SHPFileHeader.ShapeType = (int)ShapeType.Polygon; break; } SHPFileHeader.BoundingBoxXMin = _Layer.Extent.X; SHPFileHeader.BoundingBoxYMin = _Layer.Extent.Y; SHPFileHeader.BoundingBoxXMax = _Layer.Extent.X + _Layer.Extent.Width; SHPFileHeader.BoundingBoxYMax = _Layer.Extent.Y + _Layer.Extent.Height; ShapeFileHeaderWriter(ref oShpBinaryWriter, SHPFileHeader); //*** Write .Shp File Header ShapeFileHeaderWriter(ref oShxBinaryWriter, SHPFileHeader); //*** Write .Shx File Header DbaseFileHeaderWriter(ref oDbfBinaryWriter, _Layer.RecordCount, FileEncoding); //*** Write .dbf File Header int i; Shape _Shape = new Shape(); PointF[] Pts; int Offset = 50; int RecordNumber = 0; int ContentLength; int Points; IDictionaryEnumerator dicEnumerator = _Layer.Records.GetEnumerator(); switch (SHPFileHeader.ShapeType) { case 1: PointF Pt; ContentLength = 10; while (dicEnumerator.MoveNext()) { _Shape = (Shape)dicEnumerator.Value; Pt = (PointF)_Shape.Parts[0]; RecordNumber += 1; oShpBinaryWriter.Write(BigToLittleEndian(RecordNumber)); oShpBinaryWriter.Write(BigToLittleEndian(ContentLength)); oShpBinaryWriter.Write((int)1); //Shape Type oShpBinaryWriter.Write((double)Pt.X); oShpBinaryWriter.Write((double)Pt.Y); IndexRecordWriter(ref oShxBinaryWriter, Offset, ContentLength); //*** Write SHX Record Offset += (4 + ContentLength); //*** Add 4 for record header '*** Set Offset for next SHX record DbaseRecordWriter(ref oDbfBinaryWriter, _Shape.AreaId, _Shape.AreaName); //*** Write DBF Record } break; case 3: case 5: while (dicEnumerator.MoveNext()) { _Shape = (Shape)dicEnumerator.Value; int[] NumPoints = new int[_Shape.Parts.Count]; Points = 0; for (i = 0; i <= _Shape.Parts.Count - 1; i++) { Pts = (PointF[])_Shape.Parts[i]; NumPoints[i] = Pts.Length; Points += Pts.Length; } ContentLength = ((11 + _Shape.Parts.Count) * 2) + (Points * 8); RecordNumber += 1; PolygonRecordWriter(ref oShpBinaryWriter, RecordNumber, ContentLength, Points, NumPoints, _Shape, SHPFileHeader.ShapeType); IndexRecordWriter(ref oShxBinaryWriter, Offset, ContentLength); //*** Write SHX Record Offset += (4 + ContentLength); //*** Add 4 for record header '*** Set Offset for next SHX record DbaseRecordWriter(ref oDbfBinaryWriter, _Shape.AreaId, _Shape.AreaName); //*** Write DBF Record } break; } //*** Reset FileLength in Shp File Header oShpStream.Position = 24; oShpBinaryWriter.Write(BigToLittleEndian((int)oShpStream.Length / 2)); //*** Reset FileLength in Shx File Header oShxStream.Position = 24; oShxBinaryWriter.Write(BigToLittleEndian((int)oShxStream.Length / 2)); //*** Dispose oShpBinaryWriter.Close(); oShxBinaryWriter.Close(); oDbfBinaryWriter.Close(); oShpStream.Close(); oShxStream.Close(); oDbfStream.Close(); oShpBinaryWriter = null; oShxBinaryWriter = null; oDbfBinaryWriter = null; oShpStream = null; oShxStream = null; oDbfStream = null; dicEnumerator = null; }
/// <exception cref="System.IO.IOException"></exception> private void Init(string name) { a = new RawText(ReadFile(name + "_PreImage")); b = new RawText(ReadFile(name + "_PostImage")); file = ParseTestPatchFile(name + ".patch").GetFiles()[0]; }
internal void Write(BinaryWriterEx bw, List <File> files) { bw.BigEndian = BigEndian; bw.WriteASCII("BHF4"); bw.WriteBoolean(Flag1); bw.WriteBoolean(Flag2); bw.WriteByte(0); bw.WriteByte(0); bw.WriteInt32(0x10000); bw.WriteInt32(files.Count); bw.WriteInt64(0x40); bw.WriteASCII(Timestamp); if (Format == 0x0C || Format == 0x30) { bw.WriteInt64(0x18); } else if (Format == 0x2E || Format == 0x74) { bw.WriteInt64(0x24); } else if (Format == 0x3E) { bw.WriteInt64(0x28); } bw.WriteInt64(0); bw.WriteBoolean(Unicode); bw.WriteByte(Format); bw.WriteByte(Extended); bw.WriteByte(0); bw.WriteInt32(0); if (Extended == 4) { bw.ReserveInt64("HashGroups"); } else { bw.WriteInt64(0); } for (int i = 0; i < files.Count; i++) { FileHeader.Write(bw, files[i], i, Format); } for (int i = 0; i < files.Count; i++) { File file = files[i]; bw.FillInt32($"FileName{i}", (int)bw.Position); if (Unicode) { bw.WriteUTF16(file.Name, true); } else { bw.WriteShiftJIS(file.Name, true); } } if (Extended == 4) { uint groupCount = 0; for (uint p = (uint)files.Count / 7; p <= 100000; p++) { if (Util.IsPrime(p)) { groupCount = p; break; } } if (groupCount == 0) { throw new InvalidOperationException("Hash group count not determined in BXF4."); } var hashLists = new List <PathHash> [groupCount]; for (int i = 0; i < groupCount; i++) { hashLists[i] = new List <PathHash>(); } for (int i = 0; i < files.Count; i++) { var pathHash = new PathHash(i, files[i].Name); uint group = pathHash.Hash % groupCount; hashLists[group].Add(pathHash); } for (int i = 0; i < groupCount; i++) { hashLists[i].Sort((ph1, ph2) => ph1.Hash.CompareTo(ph2.Hash)); } var hashGroups = new List <HashGroup>(); var pathHashes = new List <PathHash>(); int count = 0; foreach (List <PathHash> hashList in hashLists) { int index = count; foreach (PathHash pathHash in hashList) { pathHashes.Add(pathHash); count++; } hashGroups.Add(new HashGroup(index, count - index)); } bw.Pad(0x8); bw.FillInt64("HashGroups", bw.Position); bw.ReserveInt64("PathHashes"); bw.WriteUInt32(groupCount); bw.WriteInt32(0x00080810); foreach (HashGroup hashGroup in hashGroups) { hashGroup.Write(bw); } // No padding after section 1 bw.FillInt64("PathHashes", bw.Position); foreach (PathHash pathHash in pathHashes) { pathHash.Write(bw); } } }
internal FileInfoRarFilePart(MarkHeader mh, FileHeader fh, FileInfo fi) : base(mh, fh, true) { FileInfo = fi; }
public async Task <MemoryStream> SerializeCAS(CASData saveData) { var qw = new SymbolBufferWriter(); using (MemoryStream ms = new MemoryStream()) { using (BinaryWriter bw = new BinaryWriter(ms)) { FileHeader header = new FileHeader(); header.Write(bw); //write place holder int header_size = (int)ms.Position; var retMs = new MemoryStream(); var summary_info = (List <SymbolEntry>)saveData.summary; summary_info = await GenerateChecksums(summary_info); qw.SerializeBuffer(bw, summary_info); var summary_size = ms.Position - header_size; var save_data = (List <SymbolEntry>)saveData.save_data; save_data = await GenerateChecksums(save_data); qw.SerializeBuffer(bw, save_data); var save_size = ms.Position - summary_size - header_size; byte[] summary_buffer = summary_buffer = ms.GetBuffer().Skip(header_size).Take((int)summary_size).ToArray(); header.summaryInfoChecksum = await checksumResolver.GenerateChecksum(summary_buffer); header.checksum = 0; header.dataSize = (int)(summary_size + header_size + save_size); header.summaryInfoSize = (int)summary_size; header.version = version; bw.BaseStream.Seek(0, SeekOrigin.Begin); header.Write(bw); byte[] buff = ms.GetBuffer().Take(header.dataSize).ToArray(); header.checksum = await checksumResolver.GenerateChecksum(buff); bw.BaseStream.Seek(0, SeekOrigin.Begin); header.Write(bw); buff = ms.GetBuffer(); bw.BaseStream.Seek(0, SeekOrigin.End); var desired_size = fixedFileSize - header.dataSize; for (int i = 0; i < desired_size; i++) { bw.Write((byte)'i'); } ms.WriteTo(retMs); return(retMs); } } }
public HttpResponseMessage UpdateMetadata(string fileSystemName, string fileName) { bool isConflictResolved = false; var canonicalFilename = FileHeader.Canonize(fileName); var sourceServerInfo = InnerHeaders.Value <ServerInfo>(SyncingMultipartConstants.SourceServerInfo); // REVIEW: (Oren) It works, but it seems to me it is not an scalable solution. var sourceFileETag = Guid.Parse(InnerHeaders.GetValues(Constants.MetadataEtagField).First().Trim('\"')); Log.Debug("Starting to update a metadata of file '{0}' with ETag {1} from {2} because of synchronization", fileName, sourceFileETag, sourceServerInfo); var report = new SynchronizationReport(canonicalFilename, sourceFileETag, SynchronizationType.MetadataUpdate); try { Storage.Batch(accessor => { AssertFileIsNotBeingSynced(canonicalFilename, accessor); FileLockManager.LockByCreatingSyncConfiguration(canonicalFilename, sourceServerInfo, accessor); }); SynchronizationTask.IncomingSynchronizationStarted(canonicalFilename, sourceServerInfo, sourceFileETag, SynchronizationType.MetadataUpdate); PublishSynchronizationNotification(fileSystemName, canonicalFilename, sourceServerInfo, report.Type, SynchronizationAction.Start); Storage.Batch(accessor => StartupProceed(canonicalFilename, accessor)); var localMetadata = GetLocalMetadata(canonicalFilename); var sourceMetadata = GetFilteredMetadataFromHeaders(InnerHeaders); AssertConflictDetection(canonicalFilename, localMetadata, sourceMetadata, sourceServerInfo, out isConflictResolved); Historian.UpdateLastModified(sourceMetadata); Storage.Batch(accessor => accessor.UpdateFileMetadata(canonicalFilename, sourceMetadata)); Search.Index(canonicalFilename, sourceMetadata); if (isConflictResolved) { ConflictArtifactManager.Delete(canonicalFilename); } PublishFileNotification(fileName, FileChangeAction.Update); } catch (Exception ex) { if (ShouldAddExceptionToReport(ex)) { report.Exception = ex; Log.WarnException( string.Format("Error was occurred during metadata synchronization of file '{0}' from {1}", fileName, sourceServerInfo), ex); } } finally { FinishSynchronization(canonicalFilename, report, sourceServerInfo, sourceFileETag); } PublishSynchronizationNotification(fileSystemName, fileName, sourceServerInfo, report.Type, SynchronizationAction.Finish); if (isConflictResolved) { Publisher.Publish(new ConflictNotification { FileName = fileName, Status = ConflictStatus.Resolved }); } if (report.Exception == null) { Log.Debug("Metadata of file '{0}' was synchronized successfully from {1}", fileName, sourceServerInfo); } return(this.GetMessageWithObject(report, HttpStatusCode.OK)); }
public static string SyncNameForFile(string fileName, string destination) { return(SyncNamePrefix + "/" + Uri.EscapeUriString(destination) + FileHeader.Canonize(fileName)); }
public HttpResponseMessage Rename(string fileSystemName, string fileName, string rename) { bool isConflictResolved = false; var canonicalFilename = FileHeader.Canonize(fileName); var canonicalRename = FileHeader.Canonize(rename); var sourceServerInfo = InnerHeaders.Value <ServerInfo>(SyncingMultipartConstants.SourceServerInfo); var sourceFileETag = Guid.Parse(InnerHeaders.GetValues(Constants.MetadataEtagField).First().Trim('\"')); var sourceMetadata = GetFilteredMetadataFromHeaders(InnerHeaders); Log.Debug("Starting to rename a file '{0}' to '{1}' with ETag {2} from {3} because of synchronization", fileName, rename, sourceFileETag, sourceServerInfo); var report = new SynchronizationReport(canonicalFilename, sourceFileETag, SynchronizationType.Rename); try { Storage.Batch(accessor => { AssertFileIsNotBeingSynced(canonicalFilename, accessor); FileLockManager.LockByCreatingSyncConfiguration(canonicalFilename, sourceServerInfo, accessor); }); SynchronizationTask.IncomingSynchronizationStarted(canonicalFilename, sourceServerInfo, sourceFileETag, SynchronizationType.Rename); PublishSynchronizationNotification(fileSystemName, canonicalFilename, sourceServerInfo, report.Type, SynchronizationAction.Start); Storage.Batch(accessor => StartupProceed(canonicalFilename, accessor)); var localMetadata = GetLocalMetadata(canonicalFilename); AssertConflictDetection(canonicalFilename, localMetadata, sourceMetadata, sourceServerInfo, out isConflictResolved); if (isConflictResolved) { ConflictArtifactManager.Delete(canonicalFilename); } StorageOperationsTask.RenameFile(new RenameFileOperation { FileSystem = FileSystem.Name, Name = canonicalFilename, Rename = canonicalRename, MetadataAfterOperation = sourceMetadata.WithETag(sourceFileETag).DropRenameMarkers() }); } catch (Exception ex) { if (ShouldAddExceptionToReport(ex)) { report.Exception = ex; Log.WarnException(string.Format("Error was occurred during renaming synchronization of file '{0}' from {1}", fileName, sourceServerInfo), ex); } } finally { FinishSynchronization(canonicalFilename, report, sourceServerInfo, sourceFileETag); } PublishSynchronizationNotification(fileSystemName, canonicalFilename, sourceServerInfo, report.Type, SynchronizationAction.Finish); if (isConflictResolved) { Publisher.Publish(new ConflictNotification { FileName = fileName, Status = ConflictStatus.Resolved }); } if (report.Exception == null) { Log.Debug("File '{0}' was renamed to '{1}' during synchronization from {2}", fileName, rename, sourceServerInfo); } return(GetMessageWithObject(report)); }
public static string ConflictConfigNameForFile(string fileName) { return(ConflictConfigNamePrefix + FileHeader.Canonize(fileName)); }
static void Main(string[] args) { string catFileName = ""; string inFileName = ""; string baseDirectory = "out"; bool dryRun = false; for (int i = 0; i < args.Length; i++) { if (args[i] == "-c") { catFileName = args[i + 1]; } if (args[i] == "-f") { inFileName = args[i + 1]; } if (args[i] == "-d") { baseDirectory = args[i + 1]; } if (args[i] == "--dry") { dryRun = true; } } if (inFileName.Length == 0 || !File.Exists(inFileName)) { Console.WriteLine("Usage: hpbackup -c <catalog file name> -f <data file name> [-d <output directory>]"); return; } byte[] bytes = new byte[65536]; // First, read the catalog. var catalog = new List <FileHeader>(); try { using (var stream = new FileStream(catFileName, FileMode.Open, FileAccess.Read)) { while (stream.Position < stream.Length) { var header = new FileHeader(stream); if (!header.Valid) { AlignToNextBlock(stream); continue; } catalog.Add(header); Console.WriteLine(stream.Position.ToString("X") + ": " + header.Size.ToString("X") + " -- " + header.DateTime.ToString() + " -- " + header.Name); } } } catch (Exception e) { Console.WriteLine("Error: " + e.Message); return; } // ...And read the contents, hoping that the data perfectly lines up with the contents. try { using (var stream = new FileStream(inFileName, FileMode.Open, FileAccess.Read)) { while (stream.Position < stream.Length && catalog.Count > 0) { FileHeader currentFile = null; while (catalog.Count > 0) { currentFile = catalog[0]; catalog.RemoveAt(0); if (currentFile.Size > 0) { break; } else { currentFile = null; } } if (currentFile == null) { Console.WriteLine("Warning: Reached end of catalog with file data remaining."); break; } string filePath = baseDirectory; if (currentFile.Subdirectory.Length > 0) { string[] dirArray = currentFile.Subdirectory.Split('\\'); for (int i = 0; i < dirArray.Length; i++) { filePath = Path.Combine(filePath, dirArray[i]); } } if (!dryRun) { Directory.CreateDirectory(filePath); } filePath = Path.Combine(filePath, currentFile.Name); Console.WriteLine("Restoring: " + filePath); using (var f = dryRun ? (Stream) new MemoryStream() : (Stream) new FileStream(filePath, FileMode.Create, FileAccess.Write)) { long bytesLeft = currentFile.Size; while (bytesLeft > 0) { int bytesToRead = bytes.Length; if (bytesToRead > bytesLeft) { bytesToRead = (int)bytesLeft; } stream.Read(bytes, 0, bytesToRead); f.Write(bytes, 0, bytesToRead); if (bytesLeft == currentFile.Size) { if (!QicUtils.Utils.VerifyFileFormat(currentFile.Name, bytes)) { Console.WriteLine(stream.Position.ToString("X") + " -- Warning: file format doesn't match: " + filePath); Console.ReadKey(); } } bytesLeft -= bytesToRead; } } if (!dryRun) { File.SetCreationTime(filePath, currentFile.DateTime); File.SetLastWriteTime(filePath, currentFile.DateTime); //File.SetAttributes(filePath, header.Attributes); } } if (catalog.Count > 0) { Console.WriteLine("Warning: Reached end of file data with catalog items remaining."); } } } catch (Exception e) { Console.WriteLine("Error: " + e.Message); } }
public static string SyncResultNameForFile(string fileName) { return(SyncResultNamePrefix + FileHeader.Canonize(fileName)); }
/// <summary> /// ZIP local file header /// Write file header to output file with CRC and compressed length set to zero /// </summary> /// <param name="fullFileName">Full name of the file.</param> /// <param name="archiveFileName">Name of the archive file.</param> /// <exception cref="UZipDotNet.Exception">Duplicate file name</exception> private void WriteFileHeader(string fullFileName, string archiveFileName) { // // file header // // Pos Len // 0 4 Local file header signature = 0x04034b50 // 4 2 Version needed to extract (minimum) // 6 2 General purpose bit flag // 8 2 Compression method // 10 2 File last modification time // 12 2 File last modification date // 14 4 CRC-32 // 18 4 Compressed size // 22 4 Uncompressed size // 26 2 File name length (n) // 28 2 Extra field length (m) // 30 n File name // 30+n m Extra field // save write file length for possible error _writeStartPosition = _writeStream.Length; // file info var fi = new FileInfo(fullFileName); // Directory flag bool dirFlag = (fi.Attributes & FileAttributes.Directory) != 0; // create file header structure (name, time, attributes and version) _fileHeaderInfo = new FileHeader(archiveFileName, fi.LastWriteTime, fi.Attributes, _writeStream.Length, dirFlag ? 0 : fi.Length); // compression method deflate if (!dirFlag) _fileHeaderInfo.CompMethod = 8; // test for duplicate file name if (ZipDir.BinarySearch(_fileHeaderInfo) >= 0) throw new Exception("Duplicate file name"); // local file header signature _writeFile.Write((uint)0x04034b50); // version needed to extract 2.0 (file system is dos) _writeFile.Write(_fileHeaderInfo.Version); // general purpose bit flag _writeFile.Write(_fileHeaderInfo.BitFlags); // compression method deflate _writeFile.Write(_fileHeaderInfo.CompMethod); // last mod file time _writeFile.Write(_fileHeaderInfo.FileTime); // last mod file date _writeFile.Write(_fileHeaderInfo.FileDate); // CRC-32 is set to zero until CRC will be calculated _writeFile.Write(_fileHeaderInfo.FileCRC32); // compressed size is set to zero until the compressed size is known _writeFile.Write(_fileHeaderInfo.CompSize); // uncompressed size _writeFile.Write(_fileHeaderInfo.FileSize); // convert filename string to array of bytes using DOS (IBM OEM code page 437) encoding byte[] zipFileName = Utils.EncodeFilename(_fileHeaderInfo.FileName); // file name length _writeFile.Write((Int16)zipFileName.Length); // extra field length (for file times) _writeFile.Write((Int16)(dirFlag ? 0 : 36)); // file name _writeFile.Write(zipFileName); // extra field if (!dirFlag) { // NTFS tag of length 32, reserved area of zero, File times tag of 1 with length 24 _writeFile.Write((UInt32)0x0020000a); _writeFile.Write((UInt32)0); _writeFile.Write((UInt32)0x00180001); _writeFile.Write(fi.LastWriteTime.ToFileTime()); _writeFile.Write((File.GetLastAccessTime(fullFileName).ToFileTime())); _writeFile.Write((File.GetCreationTime(fullFileName).ToFileTime())); } // save write file length for possible rewind _writeRewindPosition = _writeStream.Length; }
public static string DownloadingFileName(string fileName) { return(FileHeader.Canonize(fileName) + DownloadingFileSuffix); }
internal FileHeader toFileHeader(string response) { if (response == "") { return null; } FileHeader result = new FileHeader(); string[] flds = StringUtils.split(response, StringUtils.CARET); result.Name = flds[0]; result.AlternateName = ""; int i = 0; while (StringUtils.isNumericChar(flds[1][i])) { result.AlternateName += flds[1][i]; i++; } if (i < flds[1].Length) { result.Characteristics = new ArrayList(); do { result.Characteristics.Add(flds[1][i]); i++; } while (i < flds[1].Length); } result.LatestId = flds[2]; result.NumberOfRecords = Convert.ToInt64(flds[3]); return result; }
/// <summary> /// Inserts any missing items from the file header. /// Also formats the existing header ensuring that the top and bottom line start with 2 slashes and a space and that a newline follows the header. /// </summary> /// <param name="options"> /// The options. /// </param> /// <param name="file"> /// The file to update. /// </param> private void UpdateFileHeader(DocumentationOptions options, ICSharpFile file) { // The idea here is to load the existing header into our FileHeader object // The FileHeader object will ensure that the format of the header is correct even if we're not changing its contents // Thus we'll swap it out if its changed at the end. string fileName = file.GetSourceFile().ToProjectFile().Location.Name; UpdateFileHeaderStyle updateFileHeaderOption = options.SA1633SA1641UpdateFileHeader; if (updateFileHeaderOption == UpdateFileHeaderStyle.Ignore) { return; } DocumentationRulesConfiguration docConfig = this.GetDocumentationRulesConfig(file); string summaryText = Utils.GetSummaryText(file); FileHeader fileHeader = new FileHeader(file) { InsertSummary = options.SA1639FileHeaderMustHaveSummary }; switch (updateFileHeaderOption) { case UpdateFileHeaderStyle.ReplaceCopyrightElement: fileHeader.FileName = fileName; fileHeader.CompanyName = docConfig.CompanyName; fileHeader.CopyrightText = docConfig.Copyright; fileHeader.Summary = string.IsNullOrEmpty(fileHeader.Summary) ? summaryText : fileHeader.Summary; break; case UpdateFileHeaderStyle.ReplaceAll: fileHeader.FileName = fileName; fileHeader.CompanyName = docConfig.CompanyName; fileHeader.CopyrightText = docConfig.Copyright; fileHeader.Summary = summaryText; break; case UpdateFileHeaderStyle.InsertMissing: fileHeader.FileName = string.IsNullOrEmpty(fileHeader.FileName) ? fileName : fileHeader.FileName; fileHeader.CompanyName = string.IsNullOrEmpty(fileHeader.CompanyName) ? docConfig.CompanyName : fileHeader.CompanyName; fileHeader.CopyrightText = string.IsNullOrEmpty(fileHeader.CopyrightText) ? docConfig.Copyright : fileHeader.CopyrightText; fileHeader.Summary = string.IsNullOrEmpty(fileHeader.Summary) ? summaryText : fileHeader.Summary; break; } fileHeader.Update(); }
/// <summary> /// Loads a BTI file from a byte array. BTI files have two ways of being stored, /// both externally in their own file (simple), and embedded within another /// file (complex). If you're loading from an isolated file, simply pass the /// entire file to data and zero for the other two parameters. /// /// However, embedded files are more complicated. An embedded file stores the /// data in the following format: [bti header][bti header][bti header][bti data] /// [bti data][bti data]. The embedded bti files store their offsets relative not /// to the start of the first bti header, but to themselves. /// /// To handle this, pass the offset into the byte[] that the header is at for /// <paramref name="mainOffset"/> and then pass (btiHeaderIndex * FileHeader.Size) /// for <paramref name="dataOffset"/>. This load function will resolve the offsets /// for loading. /// </summary> /// <param name="data">Array holding entire BTI file.</param> /// <param name="mainOffset">Offset from start of array to BTI file.</param> /// <param name="dataOffset">Additional offset required by embedded BTI files.</param> public void Load(byte[] data, uint mainOffset, uint dataOffset) { _header = new FileHeader(); _header.Load(data, mainOffset); //Copy our public settings out of the header and into the BinaryTextureImage instance. Format = _header.Format; Width = _header.Width; Height = _header.Height; WrapS = _header.WrapS; WrapT = _header.WrapT; MinFilter = _header.FilterSettingMin; MagFilter = _header.FilterSettingMag; //Grab the palette data _imagePalette = new Palette(); _imagePalette.Load(data, _header.PaletteEntryCount, dataOffset + _header.PaletteDataOffset); //Now lets load a copy of the image data out of the file. _argbImageData = DecodeData(data, Width, Height, dataOffset + _header.ImageDataOffset, Format, _imagePalette, _header.PaletteFormat); }
/// <summary> /// Inserts copyright text into the file's header. /// </summary> /// <param name="file"> /// The file to insert the company name into. /// </param> public void InsertCopyrightText(ICSharpFile file) { DocumentationRulesConfiguration docConfig = this.GetDocumentationRulesConfig(file); FileHeader fileHeader = new FileHeader(file) { CopyrightText = docConfig.Copyright }; fileHeader.Update(); }
public void AfterChange(FileHeader instance, RavenJObject metadata) { }
/// <summary> /// Inserts a summary into the file's header. /// </summary> /// <param name="file"> /// The file to insert into. /// </param> public void InsertFileHeaderSummary(ICSharpFile file) { FileHeader fileHeader = new FileHeader(file) { Summary = Utils.GetSummaryText(file) }; fileHeader.Update(); }
/// <summary> /// 读取光谱文件 /// </summary> public static bool ReadFile(byte[] fileData, FileFormat fileFormat) { fileFormat.dataInfoList = null; fileFormat.acquisitionInfo = null; fileFormat.xDataList = null; fileFormat.fileInfo = null; fileFormat.yDataList = null; MainHeader mainheader = GetMainHeader(fileData); if (mainheader.fileMark == UInt16.MaxValue) //读取文件头错误 { return(false); } //填充光谱文件信息 fileFormat.fileInfo = new FileFormat.FileInfo(); fileFormat.fileInfo.createTime = CreateFileDateTime(mainheader.fileTime); fileFormat.fileInfo.dataCount = (int)mainheader.specCols; fileFormat.fileInfo.fileMemo = CommonMethod.CovertByteArrayToString(mainheader.tile, Encoding.Default); //仪器描述 仪器名称-序列号 fileFormat.fileInfo.instDescription = CommonMethod.CovertByteArrayToString(mainheader.instrument, Encoding.Default) + instSerialSeprator + CommonMethod.CovertByteArrayToString(mainheader.serialNo, Encoding.Default); fileFormat.fileInfo.modifyFlag = 0; fileFormat.fileInfo.resolution = 16; //固定值 fileFormat.fileInfo.specType = FileFormat.SPECTYPE.SPCNIR; //固定值 fileFormat.fileInfo.xType = FileFormat.XAXISTYPE.XNMETR; //mainheader.xType = 1 fileFormat.fileInfo.zType = FileFormat.ZAXISTYPE.XMSEC; //固定值 fileFormat.fileInfo.fzinc = 0.5f; //固定值 fileFormat.fileInfo.fspare = new float[8]; //固定值 //读取X轴数据(肯定是均匀的X轴) fileFormat.xDataList = new List <double[]>(); double[] tempx = new double[mainheader.specCols]; int index = 0; for (int i = 0; i < mainheader.rangeCount; i++) //每个光谱段读取 { for (int j = 0; j < mainheader.rangeCols[i]; j++) { tempx[index] = mainheader.rangeFirstX[i] + j * mainheader.rangeStepX[i]; index++; } } fileFormat.xDataList.Add(tempx); //获取Y数据以及格式信息 fileFormat.dataInfoList = new List <FileFormat.DataInfo>(); fileFormat.yDataList = new List <double[]>(); for (int i = 0; i < mainheader.fileCount; i++) { FileHeader fileHeader = GetFileHeader(fileData, i); if (fileHeader.position == UInt16.MaxValue) { return(false); } //读取Y轴数据 double[] ydata = GetSpectrumData(fileData, i); if (ydata == null || ydata.Length == 0) { return(false); } fileFormat.yDataList.Add(ydata); //Y轴数据格式 FileFormat.DataInfo info = new FileFormat.DataInfo(); info.dataTitle = CommonMethod.CovertByteArrayToString(fileHeader.sampleNo, Encoding.Default); info.dataType = FileFormat.YAXISTYPE.YABSRB; info.firstX = mainheader.rangeFirstX[0]; info.lastX = mainheader.rangeLastX[mainheader.rangeCount - 1]; info.maxYValue = ydata.Max(); info.minYValue = ydata.Min(); fileFormat.dataInfoList.Add(info); } //读取光谱参数 fileFormat.acquisitionInfo = new FileFormat.AcquisitionInfo(); fileFormat.acquisitionInfo.GAIN = 0; fileFormat.acquisitionInfo.HIGHPASS = 0; fileFormat.acquisitionInfo.LOWPASS = 0; fileFormat.acquisitionInfo.LWN = 0; fileFormat.acquisitionInfo.SPEED = null; fileFormat.acquisitionInfo.SCANS = 0; fileFormat.acquisitionInfo.SCANSBG = 0; fileFormat.acquisitionInfo.IRMODE = FileFormat.enumIRMODE.NearIR; return(true); }
public override void Save(BinaryWriter stream) { //Write the file header FileHeader header = new FileHeader(); header.ChunkCount = _chunkList.Count; header.Save(stream); //Save the current position of the stream, then allocate numChunkHeaders * chunkHeaderSize //bytes in the stream. We'll then create the chunk headers as we write the chunk data, //and then come back to this position and write the headers in afterwards. int chunkHeaderOffset = (int) stream.BaseStream.Position; stream.BaseStream.Position += _chunkList.Count*ChunkHeader.Size; List<ChunkHeader> chunkHeaders = new List<ChunkHeader>(); int rtblHeaderOffset; foreach (KeyValuePair<Type, List<BaseChunk>> pair in _chunkList) { ChunkHeader chunkHeader = new ChunkHeader(); chunkHeader.ChunkOffset = (int) stream.BaseStream.Position; chunkHeader.Tag = pair.Value[0].ChunkName; //ToDo: We're in trouble if the chunk has no children. chunkHeader.ElementCount = pair.Value.Count; chunkHeaders.Add(chunkHeader); if (chunkHeader.Tag == "RTBL") { rtblHeaderOffset = (int) stream.BaseStream.Position; stream.BaseStream.Position += pair.Value.Count*RTBLChunk.Header.Size; //Then write all of the Entry and Table pairs. foreach (BaseChunk chunk in pair.Value) { RTBLChunk rtblHeader = (RTBLChunk) chunk; rtblHeader.EntryHeader.EntryOffset = (int) stream.BaseStream.Position; //Write the EntryData to disk which writes the Table offset as being //immediately after itself. rtblHeader.EntryHeader.Entry.WriteData(stream); rtblHeader.EntryHeader.Entry.Table.WriteData(stream); } //Then go back and write all of the rtblHeaders to disk now that we've set their offsets. stream.BaseStream.Position = rtblHeaderOffset; foreach (BaseChunk baseChunk in pair.Value) { baseChunk.WriteData(stream); } //Finally skip us to the next clear spot in the damn file. stream.Seek(0, SeekOrigin.End); } else { //Write all of the chunk data into the stream for (int i = 0; i < pair.Value.Count; i++) { BaseChunk chunk = pair.Value[i]; chunk.WriteData(stream); } } } //Now that we've created teh chunk headers and they have correct offsets set, lets go back //and write them to the actual file. stream.BaseStream.Position = chunkHeaderOffset; foreach (ChunkHeader chunkHeader in chunkHeaders) { chunkHeader.WriteData(stream); } }
public static string DeletingFileName(string fileName, int deleteVersion = 0) { return(FileHeader.Canonize(fileName) + (deleteVersion > 0 ? deleteVersion.ToString(CultureInfo.InvariantCulture) : string.Empty) + DeletingFileSuffix); }
internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, MarkHeader mh, FileHeader fh, FileInfo fi) : base(mh, fh, volume.Stream, volume.Password) { this.volume = volume; FileInfo = fi; }
/// <summary> /// Inserts the company name into the file's header. /// </summary> /// <param name="file"> /// The file to insert the company name into. /// </param> public void InsertCompanyName(ICSharpFile file) { DocumentationRulesConfiguration docConfig = this.GetDocumentationRulesConfig(file); FileHeader fileHeader = new FileHeader(file) { CompanyName = docConfig.CompanyName }; fileHeader.Update(); }
public static string RenameOperationConfigNameForFile(string fileName) { return(RenameOperationConfigPrefix + FileHeader.Canonize(fileName)); }
/// <summary> /// Updates the existing header or inserts one if missing. /// </summary> /// <param name="file"> /// THe file to check the header on. /// </param> public void InsertFileHeader(ICSharpFile file) { FileHeader fileHeader = new FileHeader(file); DocumentationRulesConfiguration docConfig = this.GetDocumentationRulesConfig(file); fileHeader.FileName = file.GetSourceFile().ToProjectFile().Location.Name; fileHeader.CompanyName = docConfig.CompanyName; fileHeader.CopyrightText = docConfig.Copyright; fileHeader.Summary = Utils.GetSummaryText(file); fileHeader.Update(); }
public Task <Stream> DownloadFileAsync(FileHeader file) { return(sources[currentSource].DownloadFileAsync(file)); }
/// <summary> /// Inserts the file name into the file. /// </summary> /// <param name="file"> /// The file to insert into. /// </param> public void InsertFileName(ICSharpFile file) { string fileName = file.GetSourceFile().ToProjectFile().Location.Name; FileHeader fileHeader = new FileHeader(file) { FileName = fileName }; fileHeader.Update(); }
internal override RarFilePart CreateFilePart(FileHeader fileHeader, MarkHeader markHeader) { return(new NonSeekableStreamFilePart(markHeader, fileHeader, streamOwner)); }
public override void Load(byte[] data) { int offset = 0; FileHeader header = new FileHeader(); header.Load(data, ref offset); _chunkList = new Dictionary<Type, List<BaseChunk>>(); var chnkHeaders = new List<ChunkHeader>(); for (int i = 0; i < header.ChunkCount; i++) { ChunkHeader chunkHeader = new ChunkHeader(); chunkHeader.Load(data, ref offset); chnkHeaders.Add(chunkHeader); } var orderedList = chnkHeaders.OrderBy(kvp => kvp.ChunkOffset); foreach (ChunkHeader chunkHeader in orderedList) { for (int k = 0; k < chunkHeader.ElementCount; k++) { BaseChunk chunk; switch (chunkHeader.Tag.Substring(0, 3).ToUpper()) { case "ENV": chunk = new EnvrChunk(); break; case "COL": chunk = new ColoChunk(); break; case "PAL": chunk = new PaleChunk(); break; case "VIR": chunk = new VirtChunk(); break; case "SCL": chunk = new SclsChunk(); break; case "PLY": chunk = new PlyrChunk(); break; case "RPA": chunk = new RPATChunk(); break; case "PAT": chunk = new PathChunk(); break; case "RPP": chunk = new RppnChunk(); break; case "PPN": chunk = new PpntChunk(); break; case "SON": chunk = new SondChunk(); break; case "FIL": chunk = new FiliChunk(); break; case "MEC": chunk = new MecoChunk(); break; case "MEM": chunk = new MemaChunk(); break; case "TRE": chunk = new TresChunk(); break; case "SHI": chunk = new ShipChunk(); break; case "MUL": chunk = new MultChunk(); break; case "LGH": chunk = new LghtChunk(); break; case "LGT": chunk = new LgtvChunk(); break; case "RAR": chunk = new RaroChunk(); break; case "ARO": chunk = new ArobChunk(); break; case "EVN": chunk = new EvntChunk(); break; case "TGO": chunk = new TgobChunk(); break; case "ACT": chunk = new ActrChunk(); if (!chunkHeader.Tag.ToUpper().EndsWith("R")) { chunk.ChunkLayer = EditorHelpers.ConvertStringToLayerId(chunkHeader.Tag.ToUpper().Substring(3, 1)); } break; case "SCO": chunk = new ScobChunk(); if (!chunkHeader.Tag.EndsWith("B")) { chunk.ChunkLayer = EditorHelpers.ConvertStringToLayerId(chunkHeader.Tag.ToUpper().Substring(3, 1)); } break; case "STA": chunk = new StagChunk(); break; case "RCA": chunk = new RcamChunk(); break; case "CAM": chunk = new CamrChunk(); break; case "FLO": chunk = new FlorChunk(); break; case "TWO": chunk = new TwoDChunk(); break; case "2DM": chunk = new TwoDMAChunk(); break; case "DMA": chunk = new DMAPChunk(); break; case "LBN": chunk = new LbnkChunk(); break; case "TGD": chunk = new TgdrChunk(); break; case "RTB": chunk = new RTBLChunk(); break; default: Console.WriteLine("Unsupported Chunk Tag: " + chunkHeader.Tag + " Chunk will not be saved!"); chunk = null; break; } if(chunk == null) continue; //Console.WriteLine(chunkHeader.Tag + " offset: " + chunkHeader.ChunkOffset); chunk.ChunkName = chunkHeader.Tag; chunk.LoadData(data, ref chunkHeader.ChunkOffset); AddChunk(chunk); } } }
/// <summary> /// Unpacks the packed raw image into <paramref name="image" />. /// </summary> private void UnpackImage(FileHeader fileHeader, ByteMemoryArea image) { var w = new LeImageWriter(image.Bytes); // // Still looking for additional information on Pharlap file packing // // Packing implemented is currently based on reviewing code and interpretation of data against loading program in debugger. // Record is 16 bit word. // If bit 15 is clear ie 0-7FFF, load the next record number of bytes into memory // // If bit 15 is set, ie 8000-FFFF use value lower 15 bits for size of repeat area // Next byte (dataSize) defines size of item to be repeated // If dataSize size is larger than size of repeat area, corrupt file // if dataSize is 0, then is either fill with zero or skip, size of repeat area // Read itemSize number of bytes for the repeatData // copying repeatData until filled size of repeat area // var rdr = new LeImageReader(RawImage, FileHeaderOffset + fileHeader.offset_load_image); while (w.Position < fileHeader.memory_requirements) { if (!rdr.TryReadUInt16(out ushort us)) { throw new BadImageFormatException("Unexpected EOF while loading program."); } if ((us & 0x8000) == 0) { rdr.ReadBytes(w.Bytes, w.Position, us); w.Position += us; } else { us &= 0x7FFF; if (!rdr.TryReadByte(out var dataSize)) { throw new BadImageFormatException("Unexpected EOF while loading program."); } if (dataSize > us) { throw new BadImageFormatException("Corrupt file"); // Corrupt file, Repeated data shouldn't be bigger than size of repeat block } if (dataSize == 0) { for (int i = 0; i < us; ++i) { w.WriteByte(dataSize); } } else { var repeatData = new byte[dataSize]; for (int i = 0; i < dataSize; ++i) { if (!rdr.TryReadByte(out var b)) { throw new BadImageFormatException("Unexpected EOF while loading program."); } repeatData[i] = b; } for (int i = 0; i < us; i += dataSize) { w.WriteBytes(repeatData); } } } } }