|
public PutNextEntry ( String entryName ) : |
||
| entryName | String | /// The name of the entry to be added, including any path to be used /// within the zip file. /// |
| return | ||
/// Returns a writable stream to an empty subfile.
public Stream GetWriteStream(string subfileName)
{
Debug.Assert(!m_finished);
if (m_zipstream != null)
{
#if USE_DOTNETZIP
var entry = m_zipstream.PutNextEntry(subfileName);
entry.LastModified = System.DateTime.Now;
// entry.CompressionMethod = DotNetZip.CompressionMethod.None; no need; use the default
return(new ZipOutputStreamWrapper_DotNetZip(m_zipstream));
#else
var entry = new ZipLibrary.ZipEntry(subfileName);
entry.DateTime = System.DateTime.Now;
// There is such a thing as "Deflated, compression level 0".
// Explicitly use "Stored".
entry.CompressionMethod = (m_zipstream.GetLevel() == 0)
? ZipLibrary.CompressionMethod.Stored
: ZipLibrary.CompressionMethod.Deflated;
return(new ZipOutputStreamWrapper_SharpZipLib(m_zipstream, entry));
#endif
}
else
{
Directory.CreateDirectory(m_temporaryPath);
string fullPath = Path.Combine(m_temporaryPath, subfileName);
return(new FileStream(fullPath, FileMode.Create, FileAccess.Write));
}
}
/********************************************************
* CLASS METHODS
*********************************************************/
/// <summary>
///
/// </summary>
/// <param name="zipPath"></param>
/// <param name="filenamesAndData"></param>
/// <returns></returns>
public static bool Zip(string zipPath, System.Collections.Generic.Dictionary<string, string> filenamesAndData)
{
var success = true;
var buffer = new byte[4096];
try
{
using (var stream = new ZipOutputStream(System.IO.File.Create(zipPath)))
{
foreach (var filename in filenamesAndData.Keys)
{
var file = filenamesAndData[filename].GetBytes();
var entry = stream.PutNextEntry(filename);
using (var ms = new System.IO.MemoryStream(file))
{
int sourceBytes;
do
{
sourceBytes = ms.Read(buffer, 0, buffer.Length);
stream.Write(buffer, 0, sourceBytes);
}
while (sourceBytes > 0);
}
}
stream.Flush();
stream.Close();
}
}
catch (System.Exception err)
{
System.Console.WriteLine("Compression.ZipData(): " + err.Message);
success = false;
}
return success;
}
/// <summary>
/// Compress a given file and delete the original file. Automatically rename the file to name.zip.
/// </summary>
/// <param name="textPath">Path of the original file</param>
/// <param name="deleteOriginal">Boolean flag to delete the original file after completion</param>
/// <returns>String path for the new zip file</returns>
public static string Zip(string textPath, bool deleteOriginal = true)
{
var buffer = new byte[4096];
var zipPath = textPath.Replace(".csv", ".zip").Replace(".txt", ".zip");
using (var stream = new ZipOutputStream(File.Create(zipPath)))
{
stream.PutNextEntry(Path.GetFileName(textPath));
// copy everything from the file to the zip
using (var fs = File.OpenRead(textPath))
{
int sourceBytes;
do
{
sourceBytes = fs.Read(buffer, 0, buffer.Length);
stream.Write(buffer, 0, sourceBytes);
}
while (sourceBytes > 0);
}
}
//Delete the old text file:
if (deleteOriginal) File.Delete(textPath);
return zipPath;
}
private void ExportDirectory(ZipOutputStream zip, Directory directory)
{
foreach (var file in directory.GetFiles())
{
zip.PutNextEntry(file.Url.Substring(rootPath.Length));
fileSystem.ReadFileContents(file.Url, zip);
}
foreach (var subDirectory in directory.GetDirectories())
{
ExportDirectory(zip, subDirectory);
}
}
public int Compress(PointCloudTile tile, byte[] uncompressedBuffer, int count, byte[] compressedBuffer)
{
MemorableMemoryStream compressedStream = new MemorableMemoryStream(compressedBuffer);
using (ZipOutputStream zipStream = new ZipOutputStream(compressedStream, true))
{
zipStream.CompressionMethod = Ionic.Zip.CompressionMethod.Deflate;
zipStream.CompressionLevel = Ionic.Zlib.CompressionLevel.BestSpeed;
zipStream.PutNextEntry("a");
zipStream.Write(uncompressedBuffer, 0, count);
}
return (int)compressedStream.MaxPosition;
}
public void WriteCompressedZip(string filepath)
{
ZipOutputStream outstream = new ZipOutputStream(filepath);
outstream.CompressionLevel = Ionic.Zlib.CompressionLevel.BestSpeed;
BinaryFormatter formatter = new BinaryFormatter();
outstream.PutNextEntry("dump");
//Logger.WriteLineTimed("Started compressing search dump");
DateTime startTime = DateTime.Now;
formatter.Serialize(outstream, searchDump.StartAddress);
formatter.Serialize(outstream, searchDump.EndAddress);
outstream.Write(searchDump.mem, 0, (int)(searchDump.EndAddress - searchDump.StartAddress));
DateTime endTime = DateTime.Now;
//Logger.WriteLineTimed("Finished compressing search dump in " + (new TimeSpan(endTime.Ticks - startTime.Ticks).TotalSeconds));
outstream.PutNextEntry("list");
//Logger.WriteLineTimed("Started copying search list");
startTime = DateTime.Now;
List<UInt32> copy = new List<uint>(resultsList);
endTime = DateTime.Now;
//Logger.WriteLineTimed("Finished copying search list in " + (new TimeSpan(endTime.Ticks - startTime.Ticks).TotalSeconds));
//Logger.WriteLineTimed("Started compressing search list");
startTime = DateTime.Now;
formatter.Serialize(outstream, resultsList);
endTime = DateTime.Now;
//Logger.WriteLineTimed("Finished compressing search list in " + (new TimeSpan(endTime.Ticks - startTime.Ticks).TotalSeconds));
outstream.Close();
outstream.Dispose();
}
private Stream CompressToZip(ItemNameValueCollection entriesPathId)
{
var stream = TempStream.Create();
using (var zip = new ZipOutputStream(stream, true))
{
zip.CompressionLevel = CompressionLevel.Level3;
zip.AlternateEncodingUsage = ZipOption.AsNecessary;
zip.AlternateEncoding = Encoding.GetEncoding(Thread.CurrentThread.CurrentCulture.TextInfo.OEMCodePage);
foreach (var path in entriesPathId.AllKeys)
{
if (Canceled)
{
zip.Dispose();
stream.Dispose();
return null;
}
var counter = 0;
foreach (var entryId in entriesPathId[path])
{
var newtitle = path;
File file = null;
var convertToExt = string.Empty;
if (!string.IsNullOrEmpty(entryId))
{
file = FileDao.GetFile(entryId);
if (file.ContentLength > SetupInfo.AvailableFileSize)
{
Error = string.Format(FilesCommonResource.ErrorMassage_FileSizeZip, FileSizeComment.FilesSizeToString(SetupInfo.AvailableFileSize));
continue;
}
if (_files.ContainsKey(file.ID.ToString()))
{
if (_quotaDocsEdition || FileUtility.InternalExtension.Values.Contains(convertToExt))
convertToExt = _files[file.ID.ToString()];
if (!string.IsNullOrEmpty(convertToExt))
{
newtitle = FileUtility.ReplaceFileExtension(path, convertToExt);
}
}
}
if (0 < counter)
{
var suffix = " (" + counter + ")";
if (!string.IsNullOrEmpty(entryId))
{
newtitle = 0 < newtitle.IndexOf('.')
? newtitle.Insert(newtitle.LastIndexOf('.'), suffix)
: newtitle + suffix;
}
else
{
break;
}
}
zip.PutNextEntry(newtitle);
if (!string.IsNullOrEmpty(entryId) && file != null)
{
if (file.ConvertedType != null || !string.IsNullOrEmpty(convertToExt))
{
//Take from converter
try
{
using (var readStream = !string.IsNullOrEmpty(convertToExt)
? FileConverter.Exec(file, convertToExt)
: FileConverter.Exec(file))
{
if (readStream != null)
{
readStream.StreamCopyTo(zip);
}
}
}
catch (Exception ex)
{
Error = ex.Message;
Logger.Error(Error, ex);
}
}
else
{
using (var readStream = FileDao.GetFileStream(file))
{
readStream.StreamCopyTo(zip);
}
}
}
counter++;
}
ProgressStep();
}
return stream;
}
}
private void ExportAllData()
{
using (var stream = TempStream.Create())
{
var contactDao = _daoFactory.GetContactDao();
var contactInfoDao = _daoFactory.GetContactInfoDao();
var dealDao = _daoFactory.GetDealDao();
var casesDao = _daoFactory.GetCasesDao();
var taskDao = _daoFactory.GetTaskDao();
var historyDao = _daoFactory.GetRelationshipEventDao();
var invoiceItemDao = _daoFactory.GetInvoiceItemDao();
_totalCount += contactDao.GetAllContactsCount();
_totalCount += dealDao.GetDealsCount();
_totalCount += casesDao.GetCasesCount();
_totalCount += taskDao.GetAllTasksCount();
_totalCount += historyDao.GetAllItemsCount();
_totalCount += invoiceItemDao.GetInvoiceItemsCount();
using (var zipStream = new ZipOutputStream(stream, true))
{
zipStream.PutNextEntry("contacts.csv");
var contactData = contactDao.GetAllContacts();
var contactInfos = new StringDictionary();
contactInfoDao.GetAll()
.ForEach(item =>
{
var contactInfoKey = String.Format("{0}_{1}_{2}", item.ContactID, (int) item.InfoType, item.Category);
if (contactInfos.ContainsKey(contactInfoKey))
{
contactInfos[contactInfoKey] += "," + item.Data;
}
else
{
contactInfos.Add(contactInfoKey, item.Data);
}
});
var zipEntryData = new MemoryStream(Encoding.UTF8.GetBytes(ExportContactsToCSV(contactData, contactInfos)));
zipEntryData.StreamCopyTo(zipStream);
zipStream.PutNextEntry("oppotunities.csv");
var dealData = dealDao.GetAllDeals();
zipEntryData = new MemoryStream(Encoding.UTF8.GetBytes(ExportDealsToCSV(dealData)));
zipEntryData.StreamCopyTo(zipStream);
zipStream.PutNextEntry("cases.csv");
var casesData = casesDao.GetAllCases();
zipEntryData = new MemoryStream(Encoding.UTF8.GetBytes(ExportCasesToCSV(casesData)));
zipEntryData.StreamCopyTo(zipStream);
zipStream.PutNextEntry("tasks.csv");
var taskData = taskDao.GetAllTasks();
zipEntryData = new MemoryStream(Encoding.UTF8.GetBytes(ExportTasksToCSV(taskData)));
zipEntryData.StreamCopyTo(zipStream);
zipStream.PutNextEntry("history.csv");
var historyData = historyDao.GetAllItems();
zipEntryData = new MemoryStream(Encoding.UTF8.GetBytes(ExportHistoryToCSV(historyData)));
zipEntryData.StreamCopyTo(zipStream);
zipStream.PutNextEntry("products_services.csv");
var invoiceItemData = invoiceItemDao.GetAll();
zipEntryData = new MemoryStream(Encoding.UTF8.GetBytes(ExportInvoiceItemsToCSV(invoiceItemData)));
zipEntryData.StreamCopyTo(zipStream);
zipStream.Flush();
zipStream.Close();
stream.Position = 0;
}
var assignedURI = _dataStore.SavePrivate(String.Empty, "exportdata.zip", stream, DateTime.Now.AddDays(1));
Status = assignedURI;
_notifyClient.SendAboutExportCompleted(_author.ID, assignedURI);
Complete();
}
}
public static void Save(string filePath)
{
//Get as xml
XElement xml = Instance.GetAsXML();
XElement directoryXml = new XElement("directory");
//Save to location
using (var fs = File.Create(filePath))
{
using (ZipOutputStream s = new ZipOutputStream(fs))
{
s.PutNextEntry("ProjectInfo");
byte[] bytes = Encoding.ASCII.GetBytes(xml.ToString());
s.Write(bytes, 0, bytes.Length);
for (int i = 0; i < Instance.Files.Count; i++)
{
s.PutNextEntry(Instance.Files[i].GetXMLPath());
bytes = Instance.Files[i].GetAsBytes();
s.Write(bytes, 0, bytes.Length);
XElement fileElement = new XElement("File");
fileElement.Add(new XAttribute("ID", Instance.Files[i].GetXMLName()));
fileElement.Add(new XAttribute("Path", Instance.Files[i].GetXMLPath()));
directoryXml.Add(fileElement);
}
foreach (RomItem item in Instance.Items)
{
bytes = Encoding.ASCII.GetBytes(item.GetAsXML().ToString());
s.PutNextEntry(item.GetXMLPath());
s.Write(bytes, 0, bytes.Length);
XElement fileElement = new XElement("Item");
fileElement.Add(new XAttribute("Name", item.GetXMLName()));
fileElement.Add(new XAttribute("Path", item.GetXMLPath()));
directoryXml.Add(fileElement);
}
s.PutNextEntry("Directory");
bytes = Encoding.ASCII.GetBytes(directoryXml.ToString());
s.Write(bytes, 0, bytes.Length);
}
}
//Change the project path (???)
Instance.ProjectPath = Path.GetDirectoryName(filePath);
}
public void MakeZipStream(string Password = "")
{
if (this.Files.Count != 0)
{
this.OMS = new MemoryStream();
using (ZipOutputStream stream = new ZipOutputStream(this.OMS))
{
IEnumerator enumerator;
if (Strings.Len(Password) > 0)
{
stream.Password = this.Pass;
stream.Encryption = EncryptionAlgorithm.WinZipAes256;
}
try
{
enumerator = this.Files.GetEnumerator();
while (enumerator.MoveNext())
{
ZipFileEntry current = (ZipFileEntry)enumerator.Current;
if (current.IsDir)
{
stream.PutNextEntry(current.Name + "/");
}
else
{
stream.PutNextEntry(current.Name);
if (current.contents.Length > 0)
{
stream.Write(current.contents, 0, current.contents.Length);
}
}
}
}
finally
{
}
}
}
}
public clsResult Save(sWrite_WZ_Args Args)
{
var returnResult =
new clsResult("Compiling to \"{0}\"".Format2(Args.Path), false);
logger.Info("Compiling to \"{0}\"".Format2(Args.Path));
try
{
switch ( Args.CompileType )
{
case sWrite_WZ_Args.enumCompileType.Multiplayer:
if ( Args.Multiplayer == null )
{
returnResult.ProblemAdd("Multiplayer arguments were not passed.");
return returnResult;
}
if ( Args.Multiplayer.PlayerCount < 2 | Args.Multiplayer.PlayerCount > Constants.PlayerCountMax )
{
returnResult.ProblemAdd(string.Format("Number of players was below 2 or above {0}.", Constants.PlayerCountMax));
return returnResult;
}
break;
case sWrite_WZ_Args.enumCompileType.Campaign:
if ( Args.Campaign == null )
{
returnResult.ProblemAdd("Campaign arguments were not passed.");
return returnResult;
}
break;
default:
returnResult.ProblemAdd("Unknown compile method.");
return returnResult;
}
if ( !Args.Overwrite )
{
if ( File.Exists(Args.Path) )
{
returnResult.ProblemAdd("The selected file already exists.");
return returnResult;
}
}
if ( Args.CompileType == sWrite_WZ_Args.enumCompileType.Multiplayer )
{
if ( !Args.Overwrite )
{
if ( File.Exists(Args.Path) )
{
returnResult.ProblemAdd(string.Format("A file already exists at: {0}", Args.Path));
return returnResult;
}
}
try
{
using ( var zip = new ZipOutputStream(Args.Path) )
{
// Set encoding
zip.AlternateEncoding = Encoding.GetEncoding("UTF-8");
zip.AlternateEncodingUsage = ZipOption.Always;
// Set compression
zip.CompressionLevel = CompressionLevel.BestCompression;
// .xplayers.lev
var zipPath = string.Format("{0}c-{1}.xplayers.lev", Args.Multiplayer.PlayerCount, Args.MapName);
if ( Args.CompileType == sWrite_WZ_Args.enumCompileType.Multiplayer )
{
zip.PutNextEntry(zipPath);
returnResult.Add(Serialize_WZ_LEV(zip, Args.Multiplayer.PlayerCount,
Args.Multiplayer.AuthorName, Args.Multiplayer.License,
Args.MapName));
}
var path = string.Format("multiplay/maps/{0}c-{1}", Args.Multiplayer.PlayerCount, Args.MapName);
zip.PutNextEntry(string.Format("{0}.gam", path));
returnResult.Add(Serialize_WZ_Gam(zip, 0U,
Args.CompileType, Args.ScrollMin, Args.ScrollMax));
zip.PutNextEntry(string.Format("{0}/struct.ini", path));
var iniStruct = new IniWriter(zip);
returnResult.Add(Serialize_WZ_StructuresINI(iniStruct, Args.Multiplayer.PlayerCount));
iniStruct.Flush();
zip.PutNextEntry(string.Format("{0}/droid.ini", path));
var iniDroid = new IniWriter(zip);
returnResult.Add(Serialize_WZ_DroidsINI(iniDroid, Args.Multiplayer.PlayerCount));
iniDroid.Flush();
zip.PutNextEntry(string.Format("{0}/labels.ini", path));
var iniLabels = new IniWriter(zip);
returnResult.Add(Serialize_WZ_LabelsINI(iniLabels, Args.Multiplayer.PlayerCount));
iniLabels.Flush();
zip.PutNextEntry(string.Format("{0}/feature.ini", path));
var iniFeature = new IniWriter(zip);
returnResult.Add(Serialize_WZ_FeaturesINI(iniFeature));
iniFeature.Flush();
zip.PutNextEntry(string.Format("{0}/game.map", path));
returnResult.Add(Serialize_WZ_Map(zip));
zip.PutNextEntry(string.Format("{0}/ttypes.ttp", path));
var ttpSaver = new TTP.TTP(map);
returnResult.Add(ttpSaver.Save(zip));
}
}
catch ( Exception ex )
{
Debugger.Break();
returnResult.ProblemAdd(ex.Message);
logger.ErrorException("Got an exception", ex);
return returnResult;
}
return returnResult;
}
if ( Args.CompileType == sWrite_WZ_Args.enumCompileType.Campaign )
{
var CampDirectory = PathUtil.EndWithPathSeperator(Args.Path);
if ( !Directory.Exists(CampDirectory) )
{
returnResult.ProblemAdd(string.Format("Directory {0} does not exist.", CampDirectory));
return returnResult;
}
var filePath = string.Format("{0}{1}.gam", CampDirectory, Args.MapName);
using ( var file = File.Open(filePath, FileMode.Open | FileMode.CreateNew) )
{
returnResult.Add(Serialize_WZ_Gam(file, Args.Campaign.GAMType,
Args.CompileType, Args.ScrollMin, Args.ScrollMax));
}
CampDirectory += Args.MapName + Convert.ToString(App.PlatformPathSeparator);
try
{
Directory.CreateDirectory(CampDirectory);
}
catch ( Exception ex )
{
returnResult.ProblemAdd(string.Format("Unable to create directory {0}", CampDirectory));
logger.ErrorException("Got an exception", ex);
return returnResult;
}
filePath = CampDirectory + "droid.ini";
using ( var file = File.Open(filePath, FileMode.Open | FileMode.CreateNew) )
{
var iniDroid = new IniWriter(file);
returnResult.Add(Serialize_WZ_DroidsINI(iniDroid, -1));
iniDroid.Flush();
}
filePath = CampDirectory + "feature.ini";
using ( var file = File.Open(filePath, FileMode.Open | FileMode.CreateNew) )
{
var iniFeatures = new IniWriter(file);
returnResult.Add(Serialize_WZ_FeaturesINI(iniFeatures));
iniFeatures.Flush();
}
filePath = CampDirectory + "game.map";
using ( var file = File.Open(filePath, FileMode.Open | FileMode.CreateNew) )
{
returnResult.Add(Serialize_WZ_Map(file));
}
filePath = CampDirectory + "struct.ini";
using ( var file = File.Open(filePath, FileMode.Open | FileMode.CreateNew) )
{
var iniStruct = new IniWriter(file);
returnResult.Add(Serialize_WZ_StructuresINI(iniStruct, -1));
iniStruct.Flush();
}
filePath = CampDirectory + "ttypes.ttp";
var ttpSaver = new TTP.TTP(map);
returnResult.Add(ttpSaver.Save(filePath, false));
filePath = CampDirectory + "labels.ini";
using ( var file = File.Open(filePath, FileMode.Open | FileMode.CreateNew) )
{
var iniLabels = new IniWriter(file);
returnResult.Add(Serialize_WZ_LabelsINI(iniLabels, 0));
iniLabels.Flush();
}
}
}
catch ( Exception ex )
{
Debugger.Break();
returnResult.ProblemAdd(ex.Message);
logger.ErrorException("Got an exception", ex);
return returnResult;
}
return returnResult;
}
public void Unicode_Create_ZOS_wi12634()
{
TestContext.WriteLine("==Unicode_Create_ZOS_wi12634()=");
var filesToZip = _CreateUnicodeFiles();
byte[] buffer = new byte[2048];
int n;
// using those files create a zipfile twice. First cycle uses Unicode,
// 2nd cycle does not.
for (int j = 0; j < 2; j++)
{
// select the name of the zip file
var bpath = String.Format("wi12634-{0}.zip", j);
string zipFileToCreate = Path.Combine(TopLevelDir, bpath);
TestContext.WriteLine("========");
TestContext.WriteLine("Trial {0}", j);
Assert.IsFalse(File.Exists(zipFileToCreate),
"The zip file '{0}' already exists.",
zipFileToCreate);
TestContext.WriteLine("file {0}", zipFileToCreate);
int excCount = 0;
// create using ZOS
using (var ofs = File.Open(zipFileToCreate, FileMode.Create, FileAccess.ReadWrite))
{
using (var zos = new ZipOutputStream(ofs))
{
#pragma warning disable 618
if (j == 0)
zos.ProvisionalAlternateEncoding = System.Text.Encoding.UTF8;
#pragma warning restore 618
try
{
foreach (var fileToZip in filesToZip)
{
var ename = Path.GetFileName(fileToZip);
TestContext.WriteLine("adding entry '{0}'", ename);
zos.PutNextEntry(ename); // with no path
using (var ifs = File.OpenRead(fileToZip))
{
while ((n = ifs.Read(buffer, 0, buffer.Length)) > 0)
{
zos.Write(buffer, 0, n);
}
}
}
}
catch (System.Exception exc1)
{
TestContext.WriteLine("Exception #{0}", excCount);
TestContext.WriteLine("{0}", exc1.ToString());
excCount++;
}
}
}
Assert.IsTrue(excCount==0,
"Exceptions occurred during zip creation.");
// Verify the number of files in the zip
Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), filesToZip.Count,
"Incorrect number of entries in the zip file.");
_CheckUnicodeZip(zipFileToCreate, j);
TestContext.WriteLine("Trial {0} file checks ok", j);
}
}
/// <summary>
/// Writes a zip file
/// </summary>
/// <param name="zipPath">string - the path to the zip file to be written.</param>
/// <param name="internalFilename">string - the name of the file within the zip file. It can be a path</param>
/// <param name="data">string - the data to be written into the zip file.</param>
public static void Zip(string zipPath, string internalFilename, string data)
{
byte[] buf = Encoding.ASCII.GetBytes(data);
using (var fs = File.Create(zipPath, buf.Length))
{
using (var s = new ZipOutputStream(fs))
{
s.PutNextEntry(internalFilename);
s.Write(buf, 0, buf.Length);
}
}
}
public static void ZipToStream(Path zipPaths, Func<Path, byte[]> zipPathToContent, Stream output)
{
using (var zipStream = new ZipOutputStream(output)) {
zipStream.CompressionLevel = CompressionLevel.BestCompression;
foreach (var path in zipPaths) {
var buffer = zipPathToContent(path);
var entry = zipStream.PutNextEntry(path.ToString());
entry.CreationTime = DateTime.Now;
zipStream.Write(buffer, 0, buffer.Length);
}
zipStream.Flush();
zipStream.Close();
}
}
internal void WriteZip(ZipOutputStream os)
{
byte[] b;
if (SaveHandler == null)
{
b = GetStream().ToArray();
if (b.Length == 0) //Make sure the file isn't empty. DotNetZip streams does not seems to handle zero sized files.
{
return;
}
os.CompressionLevel = (Ionic.Zlib.CompressionLevel)CompressionLevel;
os.PutNextEntry(Uri.OriginalString);
os.Write(b, 0, b.Length);
}
else
{
SaveHandler(os, (Ionic.Zlib.CompressionLevel)CompressionLevel, Uri.OriginalString);
}
if (_rels.Count > 0)
{
string f = Uri.OriginalString;
var fi = new FileInfo(f);
_rels.WriteZip(os, (string.Format("{0}_rels/{1}.rels", f.Substring(0, f.Length - fi.Name.Length), fi.Name)));
}
b = null;
}
public void ZipOutputStream_Parallel()
{
int _sizeBase = 1024 * 1024;
int _sizeRange = 256 * 1024;
//int _sizeBase = 1024 * 256;
//int _sizeRange = 256 * 12;
var sw = new System.Diagnostics.Stopwatch();
byte[] buffer = new byte[0x8000];
int n = 0;
TimeSpan[] ts = new TimeSpan[2];
int nFiles = _rnd.Next(8) + 8;
//int nFiles = 2;
string[] filenames = new string[nFiles];
string dirToZip = Path.Combine(TopLevelDir, "dirToZip");
string channel = String.Format("ZOS_Parallel{0:000}", _rnd.Next(1000));
string txrxLabel = "ZipOutputStream Parallel";
_txrx = TestUtilities.StartProgressMonitor(channel, txrxLabel, "starting up...");
TestContext.WriteLine("Creating {0} fodder files...", nFiles);
Directory.CreateDirectory(dirToZip);
_txrx.Send(String.Format("pb 0 max {0}", nFiles));
_txrx.Send("pb 0 value 0");
sw.Start();
for (int x = 0; x < nFiles; x++)
{
string status = String.Format("status Creating file {0}/{1}", x + 1, nFiles);
_txrx.Send(status);
filenames[x] = Path.Combine(dirToZip, String.Format("file{0:000}.txt", x));
using (var output = File.Create(filenames[x]))
{
using (Stream input = new Ionic.Zip.Tests.Utilities.RandomTextInputStream(_sizeBase + _rnd.Next(_sizeRange)))
{
while ((n = input.Read(buffer, 0, buffer.Length)) != 0)
{
output.Write(buffer, 0, n);
}
}
}
_txrx.Send("pb 0 step");
}
sw.Stop();
TestContext.WriteLine("file generation took {0}", sw.Elapsed);
_txrx.Send(String.Format("pb 0 max {0}", crypto.Length));
_txrx.Send("pb 0 value 0");
for (int i = 0; i < crypto.Length; i++)
{
//int c = i;
int c = (i + 2) % crypto.Length;
_txrx.Send(String.Format("pb 1 max {0}", compLevels.Length));
_txrx.Send("pb 1 value 0");
for (int j = 0; j < compLevels.Length; j++)
{
string password = Path.GetRandomFileName();
// I wanna do 2 cycles if there is compression, so I can compare MT
// vs 1T compression. The first cycle will ALWAYS use the threaded
// compression, the 2nd will NEVER use it. If
// CompressionLevel==None, then just do one cycle.
//
int kCycles = (compLevels[j] == Ionic.Zlib.CompressionLevel.None)
? 1
: 2;
for (int k = 0; k < kCycles; k++)
{
// Also, I use Stopwatch to time the compression, and compare.
// In light of that, I wanna do one warmup, and then one timed
// trial (for t==0..2). But here again, if CompressionLevel==None, then I
// don't want to do a timing comparison, so I don't need 2 trials.
// Therefore, in that case, the "warmup" is the only trial I want to do.
// So when k==1 and Compression==None, do no cycles at all.
//
int tCycles = (compLevels[j] == Ionic.Zlib.CompressionLevel.None)
? ((k == 0) ? 1 : 0)
: 2;
if (k == 0)
{
_txrx.Send(String.Format("pb 2 max {0}", kCycles * tCycles));
_txrx.Send("pb 2 value 0");
}
for (int t = 0; t < tCycles; t++)
{
TestContext.WriteLine(new String('-', 72));
string zipFileToCreate = String.Format("ZipOutputStream_Parallel.E-{0}.C-{1}.{2}.{3}timed.zip",
crypto[c].ToString(), compLevels[j].ToString(),
(compLevels[j] == Ionic.Zlib.CompressionLevel.None)
? "NA"
: (k == 0) ? "1T" : "MT",
(t == 0) ? "not-" : "");
TestContext.WriteLine("Trial {0}.{1}.{2}.{3}", i, j, k, t);
TestContext.WriteLine("Create zip file {0}", zipFileToCreate);
_txrx.Send("status " + zipFileToCreate);
sw.Reset();
sw.Start();
using (var output = new ZipOutputStream(zipFileToCreate))
{
if (k == 0)
output.ParallelDeflateThreshold = -1L; // never
else
output.ParallelDeflateThreshold = 0L; // always
output.Password = password;
output.Encryption = crypto[c]; // maybe "None"
output.CompressionLevel = compLevels[j];
_txrx.Send(String.Format("pb 3 max {0}", nFiles));
_txrx.Send("pb 3 value 0");
for (int x = 0; x < nFiles; x++)
{
output.PutNextEntry(Path.GetFileName(filenames[x]));
using (var input = File.OpenRead(filenames[x]))
{
while ((n = input.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write(buffer, 0, n);
}
}
_txrx.Send("pb 3 step");
}
}
sw.Stop();
ts[k] = sw.Elapsed;
TestContext.WriteLine("compression took {0}", ts[k]);
//if (t==0)
BasicVerifyZip(zipFileToCreate, password);
Assert.AreEqual<int>(nFiles, TestUtilities.CountEntries(zipFileToCreate),
"Trial ({0}.{1}.{2}.{3}): The zip file created has the wrong number of entries.", i, j, k, t);
_txrx.Send("pb 2 step");
}
}
#if NOT_DEBUGGING
// parallel is not always faster!
if (_sizeBase > 256 * 1024 &&
compLevels[j] != Ionic.Zlib.CompressionLevel.None &&
compLevels[j] != Ionic.Zlib.CompressionLevel.BestSpeed &&
crypto[c] != EncryptionAlgorithm.WinZipAes256 &&
crypto[c] != EncryptionAlgorithm.WinZipAes128 )
Assert.IsTrue(ts[0]>ts[1], "Whoops! Cycle {0}.{1} (crypto({4}) Comp({5})): Parallel deflate is slower ({2}<{3})",
i, j, ts[0], ts[1],
crypto[c],
compLevels[j]);
#endif
_txrx.Send("pb 1 step");
}
_txrx.Send("pb 0 step");
}
_txrx.Send("stop");
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <param name="FilePaths"></param>
/// <param name="OutFilePath"></param>
/// <param name="Password"></param>
/// <param name="PasswordBinary"></param>
/// <param name="NewArchiveName"></param>
/// <returns></returns>
public Tuple<bool, int> Encrypt( object sender, DoWorkEventArgs e,
string[] FilePaths, string OutFilePath, string Password, byte[] PasswordBinary, string NewArchiveName)
{
BackgroundWorker worker = sender as BackgroundWorker;
byte[] bufferKey = new byte[32];
e.Result = ENCRYPTING;
_FileList = new List<string>();
try
{
using (FileStream outfs = File.Open(OutFilePath, FileMode.Create, FileAccess.ReadWrite))
{
using (var zip = new ZipOutputStream(outfs))
{
zip.AlternateEncoding = System.Text.Encoding.GetEncoding("shift_jis");
//zip.AlternateEncoding = System.Text.Encoding.UTF8;
zip.AlternateEncodingUsage = Ionic.Zip.ZipOption.Always;
// Password
zip.Password = Password;
// Encryption Algorithm
switch (AppSettings.Instance.ZipEncryptionAlgorithm)
{
case ENCRYPTION_ALGORITHM_PKZIPWEAK:
zip.Encryption = EncryptionAlgorithm.PkzipWeak;
break;
case ENCRYPTION_ALGORITHM_WINZIPAES128:
zip.Encryption = EncryptionAlgorithm.WinZipAes128;
break;
case ENCRYPTION_ALGORITHM_WINZIPAES256:
zip.Encryption = EncryptionAlgorithm.WinZipAes256;
break;
}
// Compression level
switch (AppSettings.Instance.CompressRate)
{
case 0:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
break;
case 1:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.BestSpeed;
break;
case 2:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.Level2;
break;
case 3:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.Level3;
break;
case 4:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.Level4;
break;
case 5:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.Level5;
break;
case 6:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.Default;
break;
case 7:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.Level7;
break;
case 8:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.Level8;
break;
case 9:
zip.CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression;
break;
default:
break;
}
string ParentPath;
ArrayList FileInfoList = new ArrayList();
//----------------------------------------------------------------------
// Put together files in one ( Save as the name ).
// 複数ファイルを一つにまとめる（ファイルに名前をつけて保存）
if (NewArchiveName != "")
{
ParentPath = NewArchiveName + "\\";
zip.PutNextEntry(ParentPath);
}
//----------------------------------------------------------------------
// When encrypt multiple files
// 複数のファイルを暗号化する場合
foreach (string FilePath in FilePaths)
{
ParentPath = Path.GetDirectoryName(FilePath) + "\\";
if ((worker.CancellationPending == true))
{
e.Cancel = true;
return Tuple.Create(false, USER_CANCELED);
}
//----------------------------------------------------------------------
// 暗号化リストを生成（ファイル）
// Create file to encrypt list ( File )
//----------------------------------------------------------------------
if (File.Exists(FilePath) == true)
{
ArrayList Item = GetFileInfo(ParentPath, FilePath);
FileInfoList.Add(Item);
//Item[0] // TypeFlag ( Directory: 0, file: 1 )
//Item[1] // Absolute file path
//Item[2] // Relative file path
//Item[3] // File size
// files only
if ((int)Item[0] == 1)
{
_TotalFileSize += Convert.ToInt64(Item[3]);
_FileList.Add((string)Item[1]);
}
}
//----------------------------------------------------------------------
// 暗号化リストを生成（ディレクトリ）
// Create file to encrypt list ( Directory )
//----------------------------------------------------------------------
else
{
// Directory
foreach (ArrayList Item in GetFileList(ParentPath, FilePath))
{
if ((worker.CancellationPending == true))
{
e.Cancel = true;
return Tuple.Create(false, USER_CANCELED);
}
if (NewArchiveName != "")
{
Item[2] = NewArchiveName + "\\" + Item[2] + "\\";
}
FileInfoList.Add(Item);
if (Convert.ToInt32(Item[0]) == 1)
{ // files only
_TotalFileSize += Convert.ToInt64(Item[3]); // File size
}
_FileList.Add((string)Item[1]);
}// end foreach (ArrayList Item in GetFilesList(ParentPath, FilePath));
}// if (File.Exists(FilePath) == true);
}// end foreach (string FilePath in FilePaths);
#if (DEBUG)
string DeskTopPath = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
string TempFilePath = Path.Combine(DeskTopPath, "zip_encrypt.txt");
using (StreamWriter sw = new StreamWriter(TempFilePath, false, System.Text.Encoding.UTF8))
{
foreach (ArrayList Item in FileInfoList)
{
string OneLine = Item[0] + "\t" + Item[1] + "\t" + Item[2] + "\t" + Item[3] + "\n";
sw.Write(OneLine);
}
}
#endif
_NumberOfFiles = 0;
_TotalNumberOfFiles = FileInfoList.Count;
string MessageText = "";
ArrayList MessageList = new ArrayList();
float percent;
foreach (ArrayList Item in FileInfoList)
{
//Item[0] // TypeFlag ( Directory: 0, file: 1 )
//Item[1] // Absolute file path
//Item[2] // Relative file path
//Item[3] // File size
zip.PutNextEntry((string)Item[2]);
_NumberOfFiles++;
//-----------------------------------
// Directory
if ((int)Item[0] == 0)
{
if (_TotalNumberOfFiles > 1)
{
MessageText = (string)Item[1] + " ( " + _NumberOfFiles.ToString() + " / " + _TotalNumberOfFiles.ToString() + " )";
}
else
{
MessageText = (string)Item[1];
}
percent = ((float)_TotalSize / _TotalFileSize);
MessageList = new ArrayList();
MessageList.Add(ENCRYPTING);
MessageList.Add(MessageText);
worker.ReportProgress((int)(percent * 10000), MessageList);
if (worker.CancellationPending == true)
{
e.Cancel = true;
return Tuple.Create(false, USER_CANCELED);
}
}
else
{
//-----------------------------------
// File
using (FileStream fs = File.Open((string)Item[1], FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Write))
{
byte[] buffer = new byte[BUFFER_SIZE];
int len;
while ((len = fs.Read(buffer, 0, buffer.Length)) > 0)
{
zip.Write(buffer, 0, len);
if (_TotalNumberOfFiles > 1)
{
MessageText = (string)Item[1] + " ( " + _NumberOfFiles.ToString() + " / " + _TotalNumberOfFiles.ToString() + " )";
}
else
{
MessageText = (string)Item[1];
}
_TotalSize += len;
percent = ((float)_TotalSize / _TotalFileSize);
MessageList = new ArrayList();
MessageList.Add(ENCRYPTING);
MessageList.Add(MessageText);
worker.ReportProgress((int)(percent * 10000), MessageList);
if (worker.CancellationPending == true)
{
e.Cancel = true;
return Tuple.Create(false, USER_CANCELED);
}
}// end while ((len = fs.Read(buffer, 0, buffer.Length)) > 0);
}// end using (FileStream fs = File.Open((string)Item[1], FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Write));
}// end if ((int)Item[0] == 0);
}// end foreach (ArrayList Item in FileInfoList);
}// using (var zip = new ZipOutputStream(outfs));
}// end using (FileStream outfs = File.Open(OutFilePath, FileMode.Create, FileAccess.ReadWrite));
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message);
e.Result = ERROR_UNEXPECTED;
return Tuple.Create(true, ERROR_UNEXPECTED);
}
//Encryption succeed.
e.Result = ENCRYPT_SUCCEEDED;
return Tuple.Create(true, ENCRYPT_SUCCEEDED);
}
public void Password_UnsetEncryptionAfterSetPassword_wi13909_ZOS()
{
// Verify that unsetting the Encryption property after
// setting a Password results in no encryption being used.
// This method tests ZipOutputStream.
string unusedPassword = TestUtilities.GenerateRandomPassword();
int numTotalEntries = _rnd.Next(46)+653;
string zipFileToCreate = "UnsetEncryption.zip";
using (FileStream fs = File.Create(zipFileToCreate))
{
using (var zos = new ZipOutputStream(fs))
{
zos.Password = unusedPassword;
zos.Encryption = EncryptionAlgorithm.None;
for (int i=0; i < numTotalEntries; i++)
{
if (_rnd.Next(7)==0)
{
string entryName = String.Format("{0:D5}/", i);
zos.PutNextEntry(entryName);
}
else
{
string entryName = String.Format("{0:D5}.txt", i);
zos.PutNextEntry(entryName);
if (_rnd.Next(12)==0)
{
var block = TestUtilities.GenerateRandomAsciiString() + " ";
string contentBuffer = String.Format("This is the content for entry {0}", i);
int n = _rnd.Next(6) + 2;
for (int j=0; j < n; j++)
contentBuffer += block;
byte[] buffer = System.Text.Encoding.ASCII.GetBytes(contentBuffer);
zos.Write(buffer, 0, buffer.Length);
}
}
}
}
}
BasicVerifyZip(zipFileToCreate);
}
public clsResult Save(string path, bool overwrite, bool compress)
{
var returnResult = new clsResult(string.Format("Writing FMap to \"{0}\"", path), false);
logger.Info(string.Format("Writing FMap to \"{0}\"", path));
if ( !overwrite )
{
if ( File.Exists(path) )
{
returnResult.ProblemAdd("The file already exists");
return returnResult;
}
}
try
{
using ( var zip = new ZipOutputStream(path) )
{
// Set encoding
zip.AlternateEncoding = Encoding.GetEncoding("UTF-8");
zip.AlternateEncodingUsage = ZipOption.Always;
// Set compression
if ( compress )
{
zip.CompressionLevel = CompressionLevel.BestCompression;
}
else
{
zip.CompressionMethod = CompressionMethod.None;
}
var binaryWriter = new BinaryWriter(zip, App.UTF8Encoding);
var streamWriter = new StreamWriter(zip, App.UTF8Encoding);
zip.PutNextEntry("Info.ini");
var infoIniWriter = new IniWriter(streamWriter);
returnResult.Add(serialize_FMap_Info(infoIniWriter));
streamWriter.Flush();
zip.PutNextEntry("VertexHeight.dat");
returnResult.Add(serialize_FMap_VertexHeight(binaryWriter));
binaryWriter.Flush();
zip.PutNextEntry("VertexTerrain.dat");
returnResult.Add(serialize_FMap_VertexTerrain(binaryWriter));
binaryWriter.Flush();
zip.PutNextEntry("TileTexture.dat");
returnResult.Add(serialize_FMap_TileTexture(binaryWriter));
binaryWriter.Flush();
zip.PutNextEntry("TileOrientation.dat");
returnResult.Add(serialize_FMap_TileOrientation(binaryWriter));
binaryWriter.Flush();
zip.PutNextEntry("TileCliff.dat");
returnResult.Add(serialize_FMap_TileCliff(binaryWriter));
binaryWriter.Flush();
zip.PutNextEntry("Roads.dat");
returnResult.Add(serialize_FMap_Roads(binaryWriter));
binaryWriter.Flush();
zip.PutNextEntry("Objects.ini");
var objectsIniWriter = new IniWriter(streamWriter);
returnResult.Add(serialize_FMap_Objects(objectsIniWriter));
streamWriter.Flush();
zip.PutNextEntry("Gateways.ini");
var gatewaysIniWriter = new IniWriter(streamWriter);
returnResult.Add(serialize_FMap_Gateways(gatewaysIniWriter));
streamWriter.Flush();
zip.PutNextEntry("TileTypes.dat");
returnResult.Add(serialize_FMap_TileTypes(binaryWriter));
binaryWriter.Flush();
zip.PutNextEntry("ScriptLabels.ini");
var scriptLabelsIniWriter = new IniWriter(streamWriter);
returnResult.Add(serialize_WZ_LabelsINI(scriptLabelsIniWriter));
streamWriter.Flush();
streamWriter.Close();
binaryWriter.Close();
}
}
catch ( Exception ex )
{
returnResult.ProblemAdd(ex.Message);
return returnResult;
}
return returnResult;
}
public void PackFiles(Stream strm, List<PackFileEntry> filesToPack, Callbacks callbacks)
{
SetupZIPParams();
using (ZipOutputStream zstrm = new ZipOutputStream(strm, false))
{
// always use multithreaded compression
zstrm.ParallelDeflateThreshold = 0;
foreach (PackFileEntry pfe in filesToPack)
{
zstrm.PutNextEntry(pfe.relativePathName);
byte[] data = callbacks.ReadData(pfe.relativePathName);
zstrm.Write(data, 0, data.Length);
}
}
// stream is closed automatically
}
public void SaveSearch(string filepath, List<UInt32> resultsList, Dump searchDump)
{
ZipOutputStream outstream = new ZipOutputStream(filepath);
outstream.CompressionLevel = Ionic.Zlib.CompressionLevel.BestSpeed;
BinaryFormatter formatter = new BinaryFormatter();
// First entry is the dump
outstream.PutNextEntry("dump");
//DateTime start = Logger.WriteLineTimedStarted("compressing search dump");
// Must put the addresses first, so that it can derive the right number of bytes to read for the dump
formatter.Serialize(outstream, searchDump.StartAddress);
formatter.Serialize(outstream, searchDump.EndAddress);
outstream.Write(searchDump.mem, 0, (int)(searchDump.EndAddress - searchDump.StartAddress));
//Logger.WriteLineTimedFinished("compressing search dump", start);
// Second entry is the list
outstream.PutNextEntry("list");
//start = Logger.WriteLineTimedStarted("compressing search list");
formatter.Serialize(outstream, resultsList);
//Logger.WriteLineTimedFinished("compressing search list", start);
outstream.Close();
outstream.Dispose();
}
public void ZOS_Create_DuplicateEntry()
{
string zipFileToCreate = "ZOS_Create_DuplicateEntry.zip";
string entryName = Path.GetRandomFileName();
using (var fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
output.PutNextEntry(entryName);
output.PutNextEntry(entryName);
}
}
}
public void ZOS_Create_Encrypt_wi12815()
{
string zipFileToCreate =
"ZOS_Create_Encrypt_wi12815.zip";
var content = new byte[1789];
unchecked
{
byte b = 0;
for (var i = 0; i < content.Length; i++, b++)
{
content[i] = b;
}
}
var checkBuffer = new Action<String>(stage =>
{
byte b = 0;
TestContext.WriteLine("Checking buffer ({0})", stage);
for (var i = 0; i < content.Length; i++, b++)
{
Assert.IsTrue((content[i] == b),
"Buffer was modified.");
}
});
checkBuffer("before");
using (var fileStream = File.OpenWrite(zipFileToCreate))
{
using (var zipStream = new ZipOutputStream(fileStream, true))
{
zipStream.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
zipStream.Password = "******";
#if AESCRYPTO
zipStream.Encryption = EncryptionAlgorithm.WinZipAes256;
#endif
zipStream.PutNextEntry("myentry.myext");
zipStream.Write(content, 0, content.Length);
}
}
checkBuffer("after");
}
public void ZOS_Create_Directories_Write()
{
for (int k = 0; k < 2; k++)
{
string zipFileToCreate = String.Format("ZOS_Create_Directories.{0}.zip", k);
using (var fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
byte[] buffer;
output.Encryption = EncryptionAlgorithm.None;
output.CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression;
output.PutNextEntry("entry1/");
if (k == 0)
{
buffer = System.Text.Encoding.ASCII.GetBytes("This is the content for entry #1.");
// this should fail
output.Write(buffer, 0, buffer.Length);
}
output.PutNextEntry("entry2/"); // this will be a directory
output.PutNextEntry("entry3.txt");
if (k == 0)
{
buffer = System.Text.Encoding.ASCII.GetBytes("This is the content for entry #3.");
output.Write(buffer, 0, buffer.Length);
}
output.PutNextEntry("entry4.txt"); // this will be zero length
output.PutNextEntry("entry5.txt"); // this will be zero length
}
}
}
}
public void ZOS_Create_EmptyEntries()
{
for (int i = 0; i < crypto.Length; i++)
{
for (int j = 0; j < compLevels.Length; j++)
{
string password = Path.GetRandomFileName();
for (int k = 0; k < 2; k++)
{
string zipFileToCreate = String.Format("ZOS_Create_EmptyEntries.Encryption.{0}.{1}.{2}.zip",
crypto[i].ToString(), compLevels[j].ToString(), k);
using (var fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
byte[] buffer;
output.Password = password;
output.Encryption = crypto[i];
output.CompressionLevel = compLevels[j];
output.PutNextEntry("entry1.txt");
if (k == 0)
{
buffer = System.Text.Encoding.ASCII.GetBytes("This is the content for entry #1.");
output.Write(buffer, 0, buffer.Length);
}
output.PutNextEntry("entry2.txt"); // this will be zero length
output.PutNextEntry("entry3.txt");
if (k == 0)
{
buffer = System.Text.Encoding.ASCII.GetBytes("This is the content for entry #3.");
output.Write(buffer, 0, buffer.Length);
}
output.PutNextEntry("entry4.txt"); // this will be zero length
output.PutNextEntry("entry5.txt"); // this will be zero length
}
}
BasicVerifyZip(zipFileToCreate, password);
Assert.AreEqual<int>(5, TestUtilities.CountEntries(zipFileToCreate),
"Trial ({0},{1}): The zip file created has the wrong number of entries.", i, j);
}
}
}
}
private void _ZOS_z64Over65534Entries
(Zip64Option z64option,
EncryptionAlgorithm encryption,
Ionic.Zlib.CompressionLevel compression)
{
TestContext.WriteLine("_ZOS_z64Over65534Entries hello: {0}",
DateTime.Now.ToString("G"));
int fileCount = _rnd.Next(14616) + 65536;
//int fileCount = _rnd.Next(146) + 5536;
TestContext.WriteLine("entries: {0}", fileCount);
var txrxLabel =
String.Format("ZOS #{0} 64({3}) E({1}) C({2})",
fileCount,
encryption.ToString(),
compression.ToString(),
z64option.ToString());
TestContext.WriteLine("label: {0}", txrxLabel);
string zipFileToCreate =
String.Format("ZOS.Zip64.over65534.{0}.{1}.{2}.zip",
z64option.ToString(), encryption.ToString(),
compression.ToString());
TestContext.WriteLine("zipFileToCreate: {0}", zipFileToCreate);
_txrx = TestUtilities.StartProgressMonitor(zipFileToCreate,
txrxLabel, "starting up...");
TestContext.WriteLine("generating {0} entries ", fileCount);
_txrx.Send("pb 0 max 3"); // 2 stages: Write, Count, Verify
_txrx.Send("pb 0 value 0");
string password = Path.GetRandomFileName();
string statusString = String.Format("status Encryption:{0} Compression:{1}",
encryption.ToString(),
compression.ToString());
_txrx.Send(statusString);
int dirCount = 0;
using (FileStream fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
_txrx.Send("test " + txrxLabel);
System.Threading.Thread.Sleep(400);
_txrx.Send("pb 1 max " + fileCount);
_txrx.Send("pb 1 value 0");
output.Password = password;
output.Encryption = encryption;
output.CompressionLevel = compression;
output.EnableZip64 = z64option;
for (int k = 0; k < fileCount; k++)
{
if (_rnd.Next(7) == 0)
{
// make it a directory
string entryName = String.Format("{0:D4}/", k);
output.PutNextEntry(entryName);
dirCount++;
}
else
{
string entryName = String.Format("{0:D4}.txt", k);
output.PutNextEntry(entryName);
// only a few entries are non-empty
if (_rnd.Next(18) == 0)
{
var block = TestUtilities.GenerateRandomAsciiString();
string content = String.Format("This is the content for entry #{0}.\n", k);
int n = _rnd.Next(4) + 1;
for (int j=0; j < n; j++)
content+= block;
byte[] buffer = System.Text.Encoding.ASCII.GetBytes(content);
output.Write(buffer, 0, buffer.Length);
}
}
if (k % 1024 == 0)
_txrx.Send(String.Format("status saving ({0}/{1}) {2:N0}%",
k, fileCount,
((double)k) / (0.01 * fileCount)));
else if (k % 256 == 0)
_txrx.Send("pb 1 value " + k);
}
}
}
_txrx.Send("pb 1 max 1");
_txrx.Send("pb 1 value 1");
_txrx.Send("pb 0 step");
System.Threading.Thread.Sleep(400);
TestContext.WriteLine("Counting entries ... " + DateTime.Now.ToString("G"));
_txrx.Send("status Counting entries...");
Assert.AreEqual<int>
(fileCount - dirCount,
TestUtilities.CountEntries(zipFileToCreate),
"{0}: The zip file created has the wrong number of entries.",
zipFileToCreate);
_txrx.Send("pb 0 step");
System.Threading.Thread.Sleep(140);
// basic verify. The output is really large, so we pass emitOutput=false .
_txrx.Send("status Verifying...");
TestContext.WriteLine("Verifying ... " + DateTime.Now.ToString("G"));
_numExtracted = 0;
_numFilesToExtract = fileCount;
_txrx.Send("pb 1 max " + fileCount);
System.Threading.Thread.Sleep(200);
_txrx.Send("pb 1 value 0");
BasicVerifyZip(zipFileToCreate, password, false, Streams_ExtractProgress);
_txrx.Send("pb 0 step");
System.Threading.Thread.Sleep(800);
TestContext.WriteLine("Done ... " + DateTime.Now.ToString("G"));
}
public void ZOS_Create_ZeroByteEntry_wi12964()
{
using (var zip = new Ionic.Zip.ZipOutputStream(new MemoryStream()))
{
zip.PutNextEntry("EmptyFile.txt");
zip.Write(new byte[1], 0, 0);
}
}
public void ZOS_Create_WithComment_wi10339()
{
string zipFileToCreate = "ZOS_Create_WithComment_wi10339.zip";
using (var fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
output.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
output.Comment = "Cheeso is the man!";
string entryName = String.Format("entry{0:D4}.txt", _rnd.Next(10000));
output.PutNextEntry(entryName);
string content = "This is the content for the entry.";
byte[] buffer = System.Text.Encoding.ASCII.GetBytes(content);
output.Write(buffer, 0, buffer.Length);
}
}
}
public void ZIS_ZOS_VaryCompression()
{
string resourceDir = Path.Combine(SourceDir, TestUtilities.GetBinDir("Zip.Portable.Tests"), "Resources");
var filesToAdd = Directory.GetFiles(resourceDir);
Func<int, int, bool> chooseCompression = (ix, cycle) => {
var name = Path.GetFileName(filesToAdd[ix]);
switch (cycle)
{
case 0:
return !(name.EndsWith(".zip") ||
name.EndsWith(".docx") ||
name.EndsWith(".xslx"));
case 1:
return ((ix%2)==0);
default:
return (ix == filesToAdd.Length - 1);
}
};
// Three cycles - three different ways to vary compression
for (int k=0; k < 3; k++)
{
string zipFileToCreate = String.Format("VaryCompression-{0}.zip", k);
TestContext.WriteLine("");
TestContext.WriteLine("Creating zip, cycle {0}", k);
using (var fileStream = File.OpenWrite(zipFileToCreate))
{
using (var zos = new ZipOutputStream(fileStream, true))
{
for (int i=0; i < filesToAdd.Length; i++)
{
var file = filesToAdd[i];
var shortName = Path.GetFileName(file);
bool compress = chooseCompression(i, k);
if (compress)
zos.CompressionLevel = Ionic.Zlib.CompressionLevel.Default;
else
zos.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
zos.PutNextEntry(shortName);
using (var input = File.OpenRead(file))
{
CopyStream(input, zos);
}
}
}
}
TestContext.WriteLine("");
TestContext.WriteLine("Extracting cycle {0}", k);
string extractDir = "extract-" + k;
Directory.CreateDirectory(extractDir);
using (var raw = File.OpenRead(zipFileToCreate))
{
using (var input = new ZipInputStream(raw))
{
ZipEntry e;
while ((e = input.GetNextEntry()) != null)
{
TestContext.WriteLine("entry: {0}", e.FileName);
string outputPath = Path.Combine(extractDir, e.FileName);
if (e.IsDirectory)
{
// create the directory
Directory.CreateDirectory(outputPath);
}
else
{
// create the file
using (var output = File.Create(outputPath))
{
CopyStream(input,output);
}
}
}
}
}
string[] filesUnzipped = Directory.GetFiles(extractDir);
Assert.AreEqual<int>(filesToAdd.Length, filesUnzipped.Length,
"Incorrect number of files extracted.");
}
}
public byte[] Encrypt(byte[] Data, byte[] Key)
{
MemoryStream ZipStream = new MemoryStream(20);
using (ZipOutputStream ZipOutput = new ZipOutputStream(ZipStream))
{
ZipOutput.Encryption = EncryptionAlgorithm.PkzipWeak;
ZipOutput.Password = Encoding.UTF8.GetString(Key);
ZipOutput.PutNextEntry("content");
ZipOutput.Write(Data, 0, Data.Length);
}
string EnvelopedResult = String.Format(
@"<s:Envelope xmlns:s=""http://schemas.xmlsoap.org/soap/envelope/""><s:Body><data>{0}</data></s:Body></s:Envelope>",
BitConverter.ToString(ZipStream.ToArray()).Replace("-", ""));
byte[] payload = Encoding.UTF8.GetBytes(EnvelopedResult);
return payload;
}
