void SetExtendedTimeStampTimes(ExtraField_ExtendedTimestamp tstamp, ref DateTime modTime, ref DateTime accTime, ref DateTime createTime) { if (!tstamp.DataValid) { return; } if (tstamp.ModificationTime != DateTime.MinValue) { modTime = tstamp.ModificationTime; } if (!tstamp.Local) { return; } if (tstamp.AccessTime != DateTime.MinValue) { accTime = tstamp.AccessTime; } if (tstamp.CreationTime != DateTime.MinValue) { createTime = tstamp.CreationTime; } }
/// <summary> /// Adds the file to the archive. <paramref name="sourcePath"/> is either a relative or absolute /// path to the file to add to the archive. If <paramref name="sourcePath"/> is an absolute path, /// it will be converted to a relative one by removing the root of the path (<code>/</code> on Unix /// and <code>X://</code> on Windows) and stored using the resulting path in the archive. If, however, /// the <paramref name="archivePath"/> parameter is present it represents a full in-archive (that is - /// without the <code>/</code> or <code>X://</code> part) path of the file including the file name. /// </summary> /// <returns>The file.</returns> /// <param name="sourcePath">Source path.</param> /// <param name="archivePath">Path in the archive, including file name.</param> /// <param name="permissions">Permissions.</param> /// <param name="compressionMethod">Compression method.</param> /// <param name="overwriteExisting">Overwrite existing entries in the archive.</param> public ZipEntry AddFile(string sourcePath, string archivePath = null, EntryPermissions permissions = EntryPermissions.Default, CompressionMethod compressionMethod = CompressionMethod.Default, bool overwriteExisting = true) { if (String.IsNullOrEmpty(sourcePath)) { throw new ArgumentException("Must not be null or empty", nameof(sourcePath)); } bool isDir = PlatformServices.Instance.IsDirectory(this, sourcePath); if (permissions == EntryPermissions.Default) { permissions = PlatformServices.Instance.GetFilesystemPermissions(this, sourcePath); if (permissions == EntryPermissions.Default) { permissions = isDir ? DefaultDirectoryPermissions : DefaultFilePermissions; } } if (PlatformServices.Instance.IsRegularFile(this, sourcePath)) { return(AddStream(new FileStream(sourcePath, FileMode.Open, FileAccess.Read), archivePath ?? sourcePath, permissions, compressionMethod, overwriteExisting, modificationTime: File.GetLastWriteTimeUtc(sourcePath))); } string destPath = EnsureArchivePath(archivePath ?? sourcePath, isDir); long index = PlatformServices.Instance.StoreSpecialFile(this, sourcePath, archivePath, out compressionMethod); if (index < 0) { throw GetErrorException(); } if (Native.zip_set_file_compression(archive, (ulong)index, isDir ? CompressionMethod.Store : compressionMethod, 0) < 0) { throw GetErrorException(); } PlatformServices.Instance.SetEntryPermissions(this, sourcePath, (ulong)index, permissions); ZipEntry entry = ReadEntry((ulong)index); IList <ExtraField> fields = new List <ExtraField> (); ExtraField_ExtendedTimestamp timestamp = new ExtraField_ExtendedTimestamp(entry, 0, createTime: File.GetCreationTimeUtc(sourcePath), accessTime: File.GetLastAccessTimeUtc(sourcePath), modificationTime: File.GetLastWriteTimeUtc(sourcePath)); fields.Add(timestamp); if (!PlatformServices.Instance.WriteExtraFields(this, entry, fields)) { throw GetErrorException(); } return(entry); }
/// <summary> /// Adds the stream to the archive. /// </summary> /// <returns>A new ZipEntry for the stream</returns> /// <param name="stream">The stream to add to the archive.</param> /// <param name="archivePath">The fullpath for the entry in the archive</param> /// <param name="permissions">The permissions which the stream should have when extracted (Unix Only)</param> /// <param name="compressionMethod">The compression method to use</param> /// <param name="overwriteExisting">If true an existing entry will be overwritten. If false and an existing entry exists and error will be raised</param> public ZipEntry AddStream(Stream stream, string archivePath, EntryPermissions permissions = EntryPermissions.Default, CompressionMethod compressionMethod = CompressionMethod.Default, bool overwriteExisting = true, DateTime?modificationTime = null) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } sources.Add(stream); string destPath = EnsureArchivePath(archivePath); var handle = GCHandle.Alloc(stream, GCHandleType.Normal); IntPtr h = GCHandle.ToIntPtr(handle); IntPtr source = Native.zip_source_function(archive, callback, h); long index = Native.zip_file_add(archive, destPath, source, overwriteExisting ? OperationFlags.Overwrite : OperationFlags.None); if (index < 0) { throw GetErrorException(); } if (Native.zip_set_file_compression(archive, (ulong)index, compressionMethod, 0) < 0) { throw GetErrorException(); } if (permissions == EntryPermissions.Default) { permissions = DefaultFilePermissions; } PlatformServices.Instance.SetEntryPermissions(this, (ulong)index, permissions, false); ZipEntry entry = ReadEntry((ulong)index); IList <ExtraField> fields = new List <ExtraField> (); ExtraField_ExtendedTimestamp timestamp = new ExtraField_ExtendedTimestamp(entry, 0, modificationTime: modificationTime ?? DateTime.UtcNow); fields.Add(timestamp); if (!PlatformServices.Instance.WriteExtraFields(this, entry, fields)) { throw GetErrorException(); } return(entry); }