Ejemplo n.º 1
0
 private void button1_Click(object sender, EventArgs e)
 {
     OpenFileDialog ofd = new OpenFileDialog();
     FolderBrowserDialog fbd = new FolderBrowserDialog();
     if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
     {
         ZipFile zf = new ZipFile("C:\\Users\\cpaine\\Desktop\\MyZipFile.zip");
         zf.AddDirectoryByName("Adam");
         zf.AddFile(ofd.FileName, "Adam");
         //zf.AddDirectory(fbd.SelectedPath, "");
         if.Save;
     }
 }
Ejemplo n.º 2
0
        public static void Export(IEnumerable <string> paths, Stream stream)
        {
            using (ZipFile zipFile = new ZipFile())
            {
                foreach (var p in paths)
                {
                    System.IO.DirectoryInfo di = new DirectoryInfo(p);

                    if ((di.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
                    {
                        zipFile.AddDirectory(p, di.Name);
                    }
                    else
                    {
                        zipFile.AddFile(p, "");
                    }
                }
                zipFile.Save(stream);
            }
        }
Ejemplo n.º 3
0
        public void Error_Save_NoFilename()
        {
            string testBin     = TestUtilities.GetTestBinDir(CurrentDir);
            string resourceDir = Path.Combine(testBin, "Resources");

            Directory.SetCurrentDirectory(TopLevelDir);
            string filename = Path.Combine(resourceDir, "TestStrings.txt");

            Assert.IsTrue(File.Exists(filename), String.Format("The file '{0}' doesnot exist.", filename));

            // add an entry to the zipfile, then try saving, never having specified a filename. This should fail.
            using (ZipFile zip = new ZipFile())
            {
                zip.AddFile(filename, "");
                zip.Save(); // FAIL: don't know where to save!
            }

            // should never reach this
            Assert.IsTrue(false);
        }
Ejemplo n.º 4
0
        private static string ArchiveLogFile(string logFilePath)
        {
            var directory = Path.GetDirectoryName(logFilePath);
            var fileName  = Path.GetFileNameWithoutExtension(logFilePath);

            if (directory == null)
            {
                throw new InvalidOperationException("Log directory is null.");
            }
            var zipPath = Path.Combine(directory, $"{fileName}.zip");

            using (var archive = new ZipFile())
            {
                archive.AddProgress  += ArchiveOnAddProgress;
                archive.SaveProgress += ArchiveOnSaveProgress;
                archive.AddFile(logFilePath, string.Empty);
                archive.Save(zipPath);
            }
            return(zipPath);
        }
        public static void Compress(string folderPath, string fileName)
        {
            try
            {
                string extension = ".zip";
                string file      = folderPath + @"\" + fileName;
                fileName = (fileName + extension).Replace(".bak", "");

                Thread thread = new Thread(t =>
                {
                    using (ZipFile zip = new ZipFile())
                    {
                        zip.Password         = "******";
                        zip.CompressionLevel = CompressionLevel.BestCompression;

                        FileInfo fileInfo = new FileInfo(fileName);
                        zip.AddFile(file, "");
                        DirectoryInfo di = new DirectoryInfo(file);
                        folderPath       = string.Format(@"{0}\{1}", di.Parent.FullName, fileInfo.Name);

                        zip.Save(folderPath);

                        File.Delete(file);

                        var shf    = new SHFILEOPSTRUCT();
                        shf.wFunc  = FO_DELETE;
                        shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
                        shf.pFrom  = file;
                        SHFileOperation(ref shf);

                        Console.WriteLine("Compress completed.");
                    }
                });
                thread.Start();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Compress completed.");
                Console.WriteLine(ex.Message);
            }
        }
Ejemplo n.º 6
0
        private async Task Compress()
        {
            using (ZipFile zip = new ZipFile())
            {
                zip.AlternateEncodingUsage = ZipOption.Always;
                zip.AlternateEncoding      = Encoding.GetEncoding(866);
                foreach (ListViewItem item in currentListView.SelectedItems)
                {
                    if (String.IsNullOrEmpty(item.SubItems[1].Text))
                    {
                        continue;
                    }
                    string path = currentTextBox.Text + item.SubItems[0].Text + item.SubItems[1].Text;
                    try
                    {
                        if (File.Exists(path))
                        {
                            await Task.Run(() => zip.AddFile(path, ""));
                        }
                        else
                        {
                            await Task.Run(() => zip.AddDirectory(path, ""));
                        }
                    }
                    catch (Exception ex) { MessageBox.Show(ex.Message); }
                }

                ArchiveForm archiveForm;
                if (currentListView == listView1)
                {
                    archiveForm = new ArchiveForm(zip, textBox1.Text);
                }
                else
                {
                    archiveForm = new ArchiveForm(zip, textBox2.Text);
                }
                archiveForm.ShowDialog();
                archiveForm.Dispose();
                LoadInfo(listView1, textBox1); LoadInfo(listView2, textBox2);
            }
        }
Ejemplo n.º 7
0
        public void Save()
        {
            FileStream fs = new FileStream(MyFilename, FileMode.Create, FileAccess.Write);

            byte[]  buff;
            ZipFile zipin = new ZipFile();

            foreach (SaveFileEntry ent in Files)
            {
                FileStream fs2 = new FileStream(ent.FileName, FileMode.Create, FileAccess.Write);
                fs2.Write(ent.memory.ToArray(), 0, (int)ent.memory.Length);
                fs2.Close();
                if (File.Exists(ent.FileName))
                {
                    zipin.AddFile(ent.FileName);
                    zipin.Save("temp.zip");
                }
                File.Delete(ent.FileName);
            }
            zip = zipin;
            FileStream fs3 = new FileStream("temp.zip", FileMode.Open, FileAccess.Read);
            int        len = (int)fs3.Length;

            buff = new byte[len];
            fs3.Read(buff, 0, len);
            fs3.Close();
            zipfile = new MemoryStream(buff);
            File.Delete("temp.zip");
            MemoryStream m = new MemoryStream();

            complete.Seek(8, SeekOrigin.Begin);
            int off = ReadInt(complete);

            complete.Seek(0, SeekOrigin.Begin);
            buff = new byte[off];
            complete.Read(buff, 0, off);
            m.Write(buff, 0, off);
            m.Write(zipfile.ToArray(), 0, (int)zipfile.Length);
            fs.Write(m.ToArray(), 0, (int)m.Length);
            fs.Close();
        }
Ejemplo n.º 8
0
        public void UpdateZip()
        {
            if (IsActual())
            {
                return;
            }
            using (var zip = new ZipFile())
            {
                zip.CompressionLevel = CompressionLevel.BestSpeed;
                foreach (var f in EnumerateFiles())
                {
                    var newContent = getFileContent(f);
                    if (newContent == null)
                    {
                        zip.AddFile(f.FullName, Path.GetDirectoryName(f.GetRelativePath(dir.FullName)));
                    }
                    else
                    {
                        zip.AddEntry(
                            f.GetRelativePath(dir.FullName),
                            _ =>
                        {
                            newContent.Position = 0;
                            return(newContent);
                        }, (_, s) => s.Dispose()
                            );
                    }
                }

                foreach (var fileToAdd in filesToAdd)
                {
                    var directoriesList = GetDirectoriesList(fileToAdd.Path);
                    if (!excludedDirs.Intersect(directoriesList).Any())
                    {
                        zip.UpdateEntry(fileToAdd.Path, fileToAdd.Data);
                    }
                }

                zip.Save(zipFile.FullName);
            }
        }
Ejemplo n.º 9
0
        internal static string createBookArchived(int id)
        {
            var clientfiles = HttpContext.Current.Server.MapPath("~/upload/clientsfiles/");
            var archive     = HttpContext.Current.Server.MapPath("~/archived/library-archived-" + id + ".zip");

            new Thread(() =>
            {
                string apiUrl = ConfigurationManager.AppSettings["api"] + "odata/library/books/file/" + id;

                File.Delete(archive);
                object input = new
                {
                };
                string inputJson = (new JavaScriptSerializer()).Serialize(input);
                //string inputJson = (new JavaScriptSerializer()).Serialize(input);
                WebClient client = new WebClient();
                client.Headers["Content-type"] = "application/json";
                client.Encoding = Encoding.UTF8;

                string json = client.UploadString(apiUrl, inputJson);
                var book    = (new JavaScriptSerializer()).Deserialize <BookDto>(json);
                if (book.Files.Count > 0)
                {
                    using (ZipFile zip = new ZipFile())
                    {
                        zip.AlternateEncodingUsage = ZipOption.AsNecessary;
                        // zip.AddDirectoryByName("Files");
                        foreach (var f in book.Files)
                        {
                            var fn = clientfiles + f;
                            zip.AddFile(fn, book.Title.Replace(" ", "-").Replace("<", "-").Replace(">", "-").Replace(":", "-").Replace("/", "-").Replace("|", "-").Replace("*", "-").Replace("?", "-"));
                        }



                        zip.Save(archive);
                    }
                }
            }).Start();
            return(string.Empty);
        }
Ejemplo n.º 10
0
        private void DownloadUserAttachments(String CommaSeperatedFiles)
        {
            string[] files = CommaSeperatedFiles.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

            //var archive = Server.MapPath("~/TaskAttachments/archive.zip");
            //var temp = Server.MapPath("~/TaskAttachments/temp");

            //// clear any existing archive
            //if (System.IO.File.Exists(archive))
            //{
            //    System.IO.File.Delete(archive);
            //}

            //// empty the temp folder
            //Directory.EnumerateFiles(temp).ToList().ForEach(f => System.IO.File.Delete(f));

            //// copy the selected files to the temp folder
            //foreach (var file in files)
            //{
            //    System.IO.File.Copy(file, Path.Combine(temp, Path.GetFileName(file)));
            //}

            //// create a new archive
            //ZipFile.CreateFromDirectory(temp, archive);

            using (ZipFile zip = new ZipFile())
            {
                foreach (var file in files)
                {
                    string filePath = Server.MapPath("~/TaskAttachments/" + file);
                    zip.AddFile(filePath, "files");
                }

                Response.Clear();
                Response.AddHeader("Content-Disposition", "attachment; filename=DownloadedFile.zip");
                Response.ContentType = "application/zip";
                zip.Save(Response.OutputStream);

                Response.End();
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Build commit data file.
        /// </summary>
        /// <returns>The data file path.</returns>
        public string Build(string rootDir, string tempFile, Action <int> onProgress = null)
        {
            // delete the file when exists.
            if (File.Exists(tempFile))
            {
                File.Delete(tempFile);
            }

            // compress all files
            using (var zip = new ZipFile(tempFile))
            {
                zip.CompressionLevel         = CompressionLevel.BestSpeed;
                zip.ParallelDeflateThreshold = -1;

                foreach (var file in Files)
                {
                    if (file.DiffType == Filemap.FileDiff.Type.Delete)
                    {
                        continue;
                    }

                    var entry = zip.AddFile(rootDir + file.FileName); // add file

                    // change name
                    entry.FileName = file.FileName;
                }

                if (onProgress != null)
                {
                    zip.SaveProgress += (sender, args) =>
                    {
                        onProgress((int)((float)args.EntriesSaved / args.EntriesTotal * 100.0f));
                    };
                }

                // save
                zip.Save();
            }

            return(tempFile);
        }
Ejemplo n.º 12
0
        /// <summary>
        /// It collect the uploadable files into param  GDUploader variable and
        /// it collect the unnecessary files into global deletableFiles variable.
        /// </summary>
        /// <param name="uploader"></param>
        /// <param name="localFolder"></param>
        /// <param name="driveFolder"></param>
        private void CollectUpSynchronizerData(GDUploader uploader, string localFolder, IEnumerable <string> localFiles, string driveFolder)
        {
            foreach (string path in localFiles)
            {
                if (!exceptionLocalFiles.Contains(path) && path.StartsWith(localFolder))
                {
                    string currentDrivePath = driveFolder + path.Substring(localFolder.Length);

                    if (Directory.Exists(path))
                    {
                        CollectUpSynchronizerData(uploader, path, currentDrivePath);
                    }
                    else
                    {
                        string currentDriveFolder = currentDrivePath.Substring(0, currentDrivePath.LastIndexOf('\\'));
                        string parentId           = ConvertGDFolderToGDParentId(currentDriveFolder);
                        string fileName           = GetFileName(path);

                        if (parentId != null)
                        {
                            string fileId = GetGDFileId(fileName + ".zip", parentId);

                            if (fileId != null)
                            {
                                AddToDeletableFile(fileId);
                            }
                        }

                        string zipFile = path + ".zip";
                        using (ZipFile zip = new ZipFile(zipFile))
                        {
                            zip.Password = zipPassword;
                            zip.AddFile(path, "");
                            zip.Save();

                            uploader.Add(new UploadableFile(zipFile, currentDriveFolder));
                        }
                    }
                }
            }
        }
Ejemplo n.º 13
0
        public string createPatch(string i_BaseCommonFolder, string i_Prod, string i_Build, string i_Description)
        {
            DateTime now               = DateTime.Now;
            string   timstamp          = now.ToString(TIMESTAMP_FORMAT);
            string   timstampPretty    = now.ToString(TIMESTAMP_PRETTY_FORMAT);
            string   archiveName       = string.Format(FILENAME_FORMAT, m_ProjectName, i_Prod, i_Build, timstamp);
            string   readmeName        = string.Format(README_FORMAT, m_ProjectName, i_Prod, i_Build, timstamp);
            string   userName          = Environment.UserName;
            string   machineName       = Environment.MachineName;
            string   readmeContent     = string.Format(README_CONTENT_FORMAT, archiveName, m_ProjectName, i_Prod, i_Build, timstampPretty, userName, machineName, i_Description);
            string   destinationFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            using (ZipFile zip = new ZipFile())
            {
                foreach (FilePath filePath in FilePaths)
                {
                    int    startIndex = filePath.Path.IndexOf("\\" + i_BaseCommonFolder + "\\");
                    int    endIndex   = filePath.Path.LastIndexOf("\\");
                    string path       = filePath.Path.Substring(startIndex, endIndex - startIndex);
                    string fileName   = filePath.Path.Substring(endIndex + 1);
                    if (File.Exists(filePath.Path))
                    {
                        zip.AddFile(filePath.Path, path);
                        readmeContent += string.Format("\n - {0}\\{1}", path, fileName);
                    }
                }

                zip.AddEntry(readmeName, Encoding.UTF8.GetBytes(readmeContent));
                zip.Save(archiveName);
                Directory.CreateDirectory(destinationFolder);
                if (!File.Exists(destinationFolder + "\\" + archiveName))
                {
                    File.Move(archiveName, destinationFolder + "\\" + archiveName);
                    return(destinationFolder + "\\" + archiveName);
                }
                else
                {
                    return(null);
                }
            }
        }
        public void TestZipPackage()
        {
            /*
             * IMetrics metrics = new HP.TS.Devops.CentralConnect.Plugin.General.MetricsMockup();
             * PluginResponse pluginResponse = metrics.GenerateMetrics(new MetricsRequest());
             * System.Console.WriteLine(System.Text.Encoding.Default.GetString(pluginResponse.FileContent));
             * */
            Guid   id = Guid.NewGuid();
            string currentWorkFolder = System.IO.Path.Combine(workFolder, id.ToString());

            if (!System.IO.Directory.Exists(currentWorkFolder))
            {
                System.IO.Directory.CreateDirectory(currentWorkFolder);
            }
            //this.GenerateFiles(metricsRequest, currentWorkFolder);
            //HP.TS.Devops.CentralConnect.Plugin.Toolkits.Zip.GZip.Compress(@"D:\AAA", @"D:\", id.ToString());
            string ZipFileToCreate = @"D:\" + id.ToString();
            string DirectoryToZip  = @"D:\AAA";

            using (ZipFile zip = new ZipFile())
            {
                // note: this does not recurse directories!
                String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);

                // This is just a sample, provided to illustrate the DotNetZip interface.
                // This logic does not recurse through sub-directories.
                // If you are zipping up a directory, you may want to see the AddDirectory() method,
                // which operates recursively.
                foreach (String filename in filenames)
                {
                    Console.WriteLine("Adding {0}...", filename);
                    ZipEntry e = zip.AddFile(filename);
                    e.Comment = "Added by Cheeso's CreateZip utility.";
                }

                zip.Comment = String.Format("This zip archive was created by the CreateZip example application on machine '{0}'",
                                            System.Net.Dns.GetHostName());

                zip.Save(ZipFileToCreate);
            }
        }
Ejemplo n.º 15
0
        public static void generarZipConArchivoExcel(ExcelFileSpreadsheet spreadsheet)
        {
            DateTime date         = DateTime.Now;
            String   tempFolder   = date.Date.ToString("yyyyMMdd") + date.Hour + date.Minute + date.Millisecond;
            String   downloadPath = HttpContext.Current.Server.MapPath("~") + "\\downloads\\" + tempFolder;

            Directory.CreateDirectory(downloadPath);

            String fileName = "Descarga_" + date.Date.ToString("yyyyMMdd") + "_" + date.Hour + date.Minute + date.Millisecond;

            ExcelFileUtils.createExcelFile(spreadsheet, downloadPath, fileName);

            HttpContext context = HttpContext.Current;

            context.Response.Clear();
            context.Response.ContentType = "application/zip";
            context.Response.AddHeader("content-disposition", "filename=" + fileName + ".zip");

            DirectoryInfo diFiles = new DirectoryInfo(downloadPath);

            using (ZipFile zip = new ZipFile())
            {
                foreach (FileInfo fi in diFiles.GetFiles())
                {
                    zip.AddFile(downloadPath + "/" + fi.Name, "");
                }

                zip.Save(context.Response.OutputStream);
            }

            // borrar archivos dentro del directorio virtual
            foreach (FileInfo file in diFiles.GetFiles())
            {
                file.Delete();
            }

            // borrar directorio virtual
            diFiles.Delete(true);

            context.Response.End();
        }
Ejemplo n.º 16
0
        private void CreateConfigBackup()
        {
            try
            {
                FileVersionInfo currentFv = FileVersionInfo.GetVersionInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PRoCon.exe"));
                FileVersionInfo updatedFv = FileVersionInfo.GetVersionInfo(Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Updates"), "PRoCon.exe"));

                string zipFileName = String.Format("{0}_to_{1}_backup.zip", currentFv.FileVersion, updatedFv.FileVersion);

                using (ZipFile zip = new ZipFile())
                {
                    DirectoryInfo configsDirectory = new DirectoryInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configs"));
                    FileInfo[]    configFiles      = configsDirectory.GetFiles("*.cfg");

                    foreach (FileInfo config in configFiles)
                    {
                        zip.AddFile(config.FullName, "");
                    }

                    DirectoryInfo[] connectionConfigDirectories = configsDirectory.GetDirectories("*_*");

                    foreach (DirectoryInfo connectionConfigDirectory in connectionConfigDirectories)
                    {
                        zip.AddDirectory(connectionConfigDirectory.FullName, connectionConfigDirectory.Name);
                    }

                    if (Directory.Exists(Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configs"), "Backups")) == false)
                    {
                        Directory.CreateDirectory(Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configs"), "Backups"));
                    }

                    zip.Save(Path.Combine(Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configs"), "Backups"), zipFileName));
                }

                this.Invoke(new StringParameterHandler(this.ConfigBackupSuccess), zipFileName);
            }
            catch (Exception e)
            {
                this.Invoke(new StringParameterHandler(this.ConfigBackupError), e.Message);
            }
        }
Ejemplo n.º 17
0
        /// <summary>
        /// 创建一个 zip
        /// </summary>
        public string  CreateZip(string path)
        {
            string logFail    = "";
            string logSuccess = "";
            string zipPath    = null;

            String[]  filenames = System.IO.Directory.GetFiles(path);
            DataTable dt        = excelData.Tables["table1"];

            foreach (String filename in filenames)
            {
                String filenameWithoudPath = System.IO.Path.GetFileName(filename);
                using (ZipFile zip = new ZipFile())
                {
                    ZipEntry e             = zip.AddFile(filename, "");
                    string   studentNumber = filenameWithoudPath.Substring(fileNameNumberPosition, fileNameNuberLenth);
                    string   password      = null;
                    foreach (DataRow dr in dt.Rows)
                    {
                        string a = dr[0].ToString();
                        if (studentNumber.ToString() == dr[excelNumberPosition].ToString())
                        {
                            //使用身份证号后6位加密
                            password = dr[excelIdNumberPosition].ToString().Substring(12, 6);
                            break;
                        }
                    }
                    if (password == null)
                    {
                        logFail += "学号为" + studentNumber + "的文件加密失败\n";
                        //  Console.WriteLine();
                        continue;
                    }
                    e.Password = password;
                    zipPath    = Path.Combine(path, string.Format("{0}.zip", studentNumber));
                    zip.Save(zipPath);
                    logSuccess += "学号为" + studentNumber + "的文件加密成功\n";
                }
            }
            return(logFail + logSuccess);
        }
Ejemplo n.º 18
0
        public ActionResult ProvvedimentoAiaRegionale(int id = 0)
        {
            ActionResult result = null;
            IEnumerable <DocumentoDownload> documenti = DocumentoRepository.Instance.RecuperaDocumentiDownloadPerProvvedimento(id);

            if (documenti.Count() > 0)
            {
                ZipFile      zip = new ZipFile();
                MemoryStream mss = new MemoryStream();

                foreach (DocumentoDownload d in documenti)
                {
                    string filepath = null;
                    string ext      = d.Estensione;

                    filepath = FileUtility.VADocumentoAiaRegionale(string.Format("I{0}_P{1}/{2}.{3}", d.OggettoID, d.OggettoProceduraID, d.PercorsoFile, ext));

                    if (System.IO.File.Exists(filepath))
                    {
                        zip.AddFile(filepath, "");
                    }
                }

                zip.Save(mss);
                zip.Dispose();

                mss.Seek(0, SeekOrigin.Begin);

                result = File(mss, ContentTypeByExtension(".zip"), string.Format("P_{0}.zip", id));
                if (!Request.Browser.Crawler)
                {
                    new VAWebRequestDocumentoDownloadEvent("VA Download documento", this, id, VAWebEventTypeEnum.DownloadDocumentiProvvedimento).Raise();
                }
            }
            else
            {
                result = HttpNotFound();
            }

            return(result);
        }
Ejemplo n.º 19
0
    protected void PackDown_Click(object sender, EventArgs e)
    {
        Response.Clear();
        Response.ContentType = "application/zip";
        Response.AddHeader("content-disposition", "filename=Homework.zip");
        using (ZipFile zip = new ZipFile())//解决中文乱码问题
        {
            foreach (GridViewRow gvr in GridView1.Rows)
            {
                if (((CheckBox)gvr.Cells[0].Controls[1]).Checked)
                {
                    string m = Server.MapPath((gvr.Cells[3].Controls[1] as HyperLink).NavigateUrl);
                    zip.AddFile(m, "");
                }
            }

            zip.Save(Response.OutputStream);
        }

        //Response.End();
    }
Ejemplo n.º 20
0
        public static Error ZipFolder(string sourcePath, string outputZipFilename)
        {
            var error = new Error();

            try {
                using (ZipFile zip = new ZipFile()) {
                    string[] fileNames = Directory.GetFiles(sourcePath, "*.*", SearchOption.AllDirectories);
                    foreach (string file in fileNames)
                    {
                        string folderName = file.Replace(sourcePath, "");
                        folderName = folderName.Replace("\\" + folderName.FileName(), "");
                        zip.AddFile(file, folderName);
                    }
                    zip.Save(outputZipFilename);
                }
            } catch (Exception e1) {
                error.SetError(e1.Message, "");
            }

            return(error);
        }
Ejemplo n.º 21
0
 private static bool Save(List <string> files)
 {
     try
     {
         if (File.Exists(ZipfilePath))
         {
             File.Delete(ZipfilePath);
         }
         Thread.Sleep(500);
         using (ZipFile zip = new ZipFile())
         {
             foreach (string file in files)
             {
                 zip.AddFile(file);
             }
             zip.Save(ZipfilePath);
         }
         return(true);
     }
     catch { return(false); }
 }
Ejemplo n.º 22
0
        public static void Comprimir(string filePath, string zipName)
        {
            ZipFile zip;

            try
            {
                using (zip = new ZipFile())
                {
                    zip.AddFile(filePath, string.Empty);
                    zip.Save(zipName);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                zip = null;
            }
        }
Ejemplo n.º 23
0
        // Takes an array of files to zip, returns an array of files which have been generated
        private void zipTheseFiles(string[] embedFiles, string outputLocation)
        {
            // ZIP it, MD5 it, and rename the file to MD5 + correct file extension

            ZipFile zip = new ZipFile();

            string tempFile = outputLocation + @"\temp.zip";

            // For each payload zip it
            foreach (string thisfile in embedFiles)
            {
                zip.AddFile(thisfile, "");
                zip.Save(tempFile);
                copyFileUniqueFilename(tempFile, outputLocation);
                // MessageBox.Show("Zipfile '" + filename + "' created");
                // TODO log
                zip.RemoveEntry(Path.GetFileName(thisfile));
            }
            // Destroy zip, remove tempfile
            System.IO.File.Delete(tempFile);
        }
Ejemplo n.º 24
0
        public static bool Zip_Files(List <string> listSelectedFile, string Password, string DestinationPath, string ZipName)
        {
            if (listSelectedFile != null)
            {
                using (ZipFile zip = new ZipFile())
                {
                    zip.Password = (Password);
                    foreach (var sFile in listSelectedFile)
                    {
                        zip.AddFile(sFile);
                    }
                    zip.Save(DestinationPath + "\\" + ZipName + extension);

                    return(true);
                }
            }



            return(false);
        }
Ejemplo n.º 25
0
        public static void ZipFiles(string[] files, string destination)
        {
            using (var zip = new ZipFile())
            {
                foreach (var file in files)
                {
                    if (System.IO.File.Exists(file))
                    {
                        zip.AddFile(file);
                    }

                    zip.Save(destination);
                }

                if (R.DebugMode && files.Length > 0)
                {
                    var track = Diagnostic.TrackMessages(files);
                    Diagnostic.Debug(typeof(File).Name, track, "Compacted {0} files to {1}", files.Length, destination);
                }
            }
        }
Ejemplo n.º 26
0
        public void DownloadFilesChkBox()
        {
            using (ZipFile zip = new ZipFile())
            {
                zip.AlternateEncodingUsage = ZipOption.AsNecessary;
                string[] s = Request.Form["chkselect"].Split(',');
                foreach (string value in s)
                {
                    string filePath = value.ToString();
                    zip.AddFile(filePath, "");
                }

                Response.Clear();
                Response.BufferOutput = false;
                string zipName = String.Format("Zip_{0}.zip", DateTime.Now.ToString("yyyy-MMM-dd-HHmmss"));
                Response.ContentType = "application/zip";
                Response.AddHeader("content-disposition", "attachment; filename=" + zipName);
                zip.Save(Response.OutputStream);
                Response.End();
            }
        }
Ejemplo n.º 27
0
        private void btnTestCompress_Click(object sender, EventArgs e)
        {
            using (var zip = new ZipFile(Encoding.Default))
            {
                if (System.IO.File.Exists(txtFilePath.Text))
                {
                    zip.AddFile(txtFilePath.Text);
                }

                if (Directory.Exists(txtDirPath.Text))
                {
                    DirectoryInfo di = new DirectoryInfo(txtDirPath.Text);
                    zip.AddDirectory(di.FullName, di.Name);
                }

                zip.Save(DEFAULT_ZIP_FILE_NAME);
                LogOperate("Compressed File:" + DEFAULT_ZIP_FILE_NAME);

                System.Diagnostics.Process.Start("explorer.exe", Application.StartupPath);
            }
        }
Ejemplo n.º 28
0
        private void btnMakeFullArchive_Click(object sender, EventArgs e)
        {
            using (ZipFile zip = new ZipFile(Encoding.GetEncoding("shift_jis"))) {
                zip.CompressionLevel = CompressionLevel.BestCompression;
                //ファイルを追加

                AddDllFilesToZip(zip);
                AddBinFilesToZip(zip, "");

                CopyFile(publishDir + "\\" + dbUpdateFile, dbUpdateFile);
                CopyFile(publishDir + "\\" + dbFile, dstDbFile);
                RunDatabaseUpdater(dstDbFile, dbUpdateFile);
                zip.AddFile(dstDbFile);

                string target = Archiver.Properties.Settings.Default.archivePrefix + "v" +
                                GetVersionStr(binDir + "\\" + Archiver.Properties.Settings.Default.mainBin) + ".zip";
                zip.Save(target);
            }

            MessageBox.Show("正常終了");
        }
Ejemplo n.º 29
0
        public string exportar(List <string> files)
        {
            try
            {
                ZipFile zip = new ZipFile();

                foreach (var f in files)
                {
                    zip.AddFile(f);
                }

                string filename = "Exportacion" + DateTime.Now.ToString("yyyy-MM-dd-HHmmss") + ".zip";
                zip.Save(filename);

                return(filename);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Ejemplo n.º 30
0
 public ActionResult Index(List <ArchivoModel> files)
 {
     using (ZipFile zip = new ZipFile())
     {
         zip.AlternateEncodingUsage = ZipOption.AsNecessary;
         zip.AddDirectoryByName("Files");
         foreach (ArchivoModel file in files)
         {
             if (file.IsSelected)
             {
                 zip.AddFile(file.FilePath, "Files");
             }
         }
         string zipName = String.Format("Comprimido_{0}.zip", DateTime.Now.ToString("yyyyMMdd-HHmm"));
         using (MemoryStream memoryStream = new MemoryStream())
         {
             zip.Save(memoryStream);
             return(File(memoryStream.ToArray(), "application/zip", zipName));
         }
     }
 }
Ejemplo n.º 31
0
 /// <summary>
 /// Архивирование файла или папки.
 /// </summary>
 /// <param name="NewName">Путь, куда нужно сохранить архив.</param>
 public void arhiv(string NewName)
 {
     try
     {
         ZipFile _str = new ZipFile(NewName);
         foreach (string s in SDirectory.GetDirectories(dname))
         {
             _str.AddDirectory(s, s);
             foreach (string f in SDirectory.GetFiles(s))
             {
                 _str.AddFile(f, s);
             }
         }
         _str.Save(NewName);
     }
     catch (Exception e)
     {
         LogForOperations("Архивирование папки", e.Message);
         throw e;
     }
 }
Ejemplo n.º 32
0
        static void Test5()
        {
            using (var zf = new ZipFile())
            {
                zf.AddFile("XCode.pdb");
                zf.AddFile("NewLife.Core.pdb");

                zf.Write("test.zip");
                zf.Write("test.7z");
            }
            //using (var zf = new ZipFile("Test.lzma.zip"))
            //{
            //    foreach (var item in zf.Entries.Values)
            //    {
            //        Console.WriteLine("{0} {1}", item.FileName, item.CompressionMethod);
            //    }

            //    zf.Extract("lzma");
            //}
        }
Ejemplo n.º 33
0
        public void Password_AddEntryWithPasswordToExistingZip()
        {
            string zipFileToCreate = "AddEntryWithPasswordToExistingZip.zip";

            string[] filenames =
            {
                Path.Combine(SourceDir, "Tools", TestUtilities.GetBinDir("Zipit"), "Zipit.exe"),
                Path.Combine(SourceDir, TestUtilities.GetBinDir("Zip.Portable"), "Zip.Portable.xml"),
            };

            string[] checksums =
            {
                TestUtilities.GetCheckSumString(filenames[0]),
                TestUtilities.GetCheckSumString(filenames[1]),
            };

            int j = 0;
            using (ZipFile zip = new ZipFile())
            {
                for (j = 0; j < filenames.Length; j++)
                    zip.AddFile(filenames[j], "");
                zip.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 2,
                    "wrong number of entries.");

            string fileX = Path.Combine(SourceDir, "Tools", TestUtilities.GetBinDir("Unzip"), "unzip.exe");
            string checksumX = TestUtilities.GetCheckSumString(fileX);
            string password = TestUtilities.GenerateRandomPassword() + "!";
            using (ZipFile zip = FileSystemZip.Read(zipFileToCreate))
            {
                zip.Password = password;
                zip.AddFile(fileX, "");
                zip.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 3,
                    "wrong number of entries.");

            string unpackDir = "unpack";
            string newpath, chk, baseName;
            using (ZipFile zip = FileSystemZip.Read(zipFileToCreate))
            {
                for (j = 0; j < filenames.Length; j++)
                {
                    baseName = Path.GetFileName(filenames[j]);
                    zip[baseName].Extract(unpackDir, ExtractExistingFileAction.OverwriteSilently);
                    newpath = Path.Combine(unpackDir, filenames[j]);
                    chk = TestUtilities.GetCheckSumString(newpath);
                    Assert.AreEqual<string>(checksums[j], chk, "Checksums do not match.");
                }

                baseName = Path.GetFileName(fileX);

                zip[baseName].ExtractWithPassword(unpackDir,
                                                  ExtractExistingFileAction.OverwriteSilently,
                                                  password);

                newpath = Path.Combine(unpackDir, fileX);
                chk = TestUtilities.GetCheckSumString(newpath);
                Assert.AreEqual<string>(checksumX, chk, "Checksums do not match.");
            }
        }
Ejemplo n.º 34
0
        private void CreateSmallZip(string zipFileToCreate)
        {

            // the list of filenames to add to the zip
            string[] fileNames =
                {
                    Path.Combine(SourceDir, "Tools", TestUtilities.GetBinDir("Zipit"), "Zipit.exe"),
                    Path.Combine(SourceDir, TestUtilities.GetBinDir("Zip.Portable"), "Zip.Portable.xml"),
                    Path.Combine(SourceDir, "Tools", "WinFormsApp", "Icon2.res"),
                };

            using (ZipFile zip = new ZipFile())
            {
                for (int j = 0; j < fileNames.Length; j++)
                    zip.AddFile(fileNames[j], "");
                zip.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 fileNames.Length,
                                 "Wrong number of entries.");
        }
Ejemplo n.º 35
0
            public void SaveZipToFile(FileName toSave)
            {
                ZipFile zip = new ZipFile(toSave.FullName);

                foreach (ZipListItem item in list)
                {
                   switch (item.Type)
                   {
                  case ZipListItemType.FILE:
                     zip.AddFile(item.Item, item.PathInZip.Path);
                     break;
                  case ZipListItemType.FOLDER:
                     zip.AddDirectory(item.Item, item.PathInZip.Path);
                     break;
                  default:
                     break;
                   }
                }

                zip.Save();
            }
Ejemplo n.º 36
0
        public void Error_AddFile_Twice()
        {
            int i;
            // select the name of the zip file
            string zipFileToCreate = Path.Combine(TopLevelDir, "Error_AddFile_Twice.zip");

            // create the subdirectory
            string subdir = Path.Combine(TopLevelDir, "files");
            Directory.CreateDirectory(subdir);

            // create a bunch of files
            int numFilesToCreate = _rnd.Next(23) + 14;
            for (i = 0; i < numFilesToCreate; i++)
                TestUtilities.CreateUniqueFile("bin", subdir, _rnd.Next(10000) + 5000);

            // Create the zip archive
            Directory.SetCurrentDirectory(TopLevelDir);
            using (ZipFile zip1 = new ZipFile(zipFileToCreate))
            {
                zip1.StatusMessageTextWriter = System.Console.Out;
                string[] files = Directory.GetFiles(subdir);
                zip1.AddFiles(files, "files");
                zip1.Save();
            }


            // this should fail - adding the same file twice
            using (ZipFile zip2 = new ZipFile(zipFileToCreate))
            {
                zip2.StatusMessageTextWriter = System.Console.Out;
                string[] files = Directory.GetFiles(subdir);
                for (i = 0; i < files.Length; i++)
                    zip2.AddFile(files[i], "files");
                zip2.Save();
            }
        }
Ejemplo n.º 37
0
        [ExpectedException(typeof(ZipException))] // not sure which exception - could be one of several.
        public void Error_ReadCorruptedZipFile()
        {
            int i;
            string zipFileToCreate = Path.Combine(TopLevelDir, "Read_CorruptedZipFile.zip");

            string sourceDir = CurrentDir;
            for (i = 0; i < 3; i++)
                sourceDir = Path.GetDirectoryName(sourceDir);

            Directory.SetCurrentDirectory(TopLevelDir);

            // the list of filenames to add to the zip
            string[] filenames =
            {
                Path.Combine(sourceDir, "Tools\\Zipit\\bin\\Debug\\Zipit.exe"),
                Path.Combine(sourceDir, "Tools\\Unzip\\bin\\Debug\\Unzip.exe"),
                Path.Combine(sourceDir, "Zip\\bin\\Debug\\Ionic.Zip.xml"),
                Path.Combine(sourceDir, "Tools\\WinFormsApp\\Icon2.res"),
            };

            // create the zipfile, adding the files
            using (ZipFile zip = new ZipFile())
            {
                for (i = 0; i < filenames.Length; i++)
                    zip.AddFile(filenames[i], "");
                zip.Save(zipFileToCreate);
            }

            // now corrupt the zip archive
            IntroduceCorruption(zipFileToCreate);

            try
            {
                // read the corrupted zip - this should fail in some way
                using (ZipFile zip = new ZipFile(zipFileToCreate))
                {
                    foreach (var e in zip)
                    {
                        System.Console.WriteLine("name: {0}  compressed: {1} has password?: {2}",
                            e.FileName, e.CompressedSize, e.UsesEncryption);
                        e.Extract("extract");
                    }
                }
            }
            catch (Exception exc1)
            {
                throw new ZipException("expected", exc1);
            }
        }
Ejemplo n.º 38
0
        public void Error_AddFile_SpecifyingDirectory()
        {
            string zipFileToCreate = "AddFile_SpecifyingDirectory.zip";
            string badfilename = "ThisIsADirectory.txt";
            Directory.CreateDirectory(badfilename);

            using (ZipFile zip = new ZipFile())
            {
                zip.AddFile(badfilename); // should fail
                zip.Save(zipFileToCreate);
            }
        }
Ejemplo n.º 39
0
        private void CreateSmallZip(string zipFileToCreate)
        {
            string sourceDir = CurrentDir;
            for (int i = 0; i < 3; i++)
                sourceDir = Path.GetDirectoryName(sourceDir);

            // the list of filenames to add to the zip
            string[] fileNames =
                {
                    Path.Combine(sourceDir, "Tools\\Zipit\\bin\\Debug\\Zipit.exe"),
                    Path.Combine(sourceDir, "Zip\\bin\\Debug\\Ionic.Zip.xml"),
                    Path.Combine(sourceDir, "Tools\\WinFormsApp\\Icon2.res"),
                };

            using (ZipFile zip = new ZipFile())
            {
                for (int j = 0; j < fileNames.Length; j++)
                    zip.AddFile(fileNames[j], "");
                zip.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 fileNames.Length,
                                 "Wrong number of entries.");
        }
Ejemplo n.º 40
0
        private void btnExportar_Click(object sender, EventArgs e)
        {
            string pastaExportacao = Program.raizExportacao + "\\Exportados";
            if (!Directory.Exists(pastaExportacao))
                Directory.CreateDirectory(pastaExportacao);

            if (txtCnpj.Text.Length < 10 || txtRazaoSocial.Text.Length < 5 || txtNomeFantasia.Text.Length < 5 || txtUsuario.Text.Length < 2)
            {
                MessageBox.Show("Digite dados válidos");
                return;
            }
            bool valido = Utils.ValidaCNPJ(txtCnpj.Text);

            if (!valido)
            {
                MessageBox.Show("O Cpnj não é válido");
                return;
            }

            IDataReader dr;
            string arquivo;

            try
            {
                txtCnpj.Text = txtCnpj.Text.ToUpper();
                txtNomeFantasia.Text = txtNomeFantasia.Text.ToUpper();
                txtRazaoSocial.Text = txtRazaoSocial.Text.ToUpper();
                txtUsuario.Text = txtUsuario.Text.ToUpper();

                arquivo = "c:\\DadosExportados "+ txtNomeFantasia.Text +".dbf";

                if (File.Exists(arquivo))
                    File.Delete(arquivo);

                IObjectContainer dbXXX = Db4oFactory.OpenFile(arquivo);

                #region Marca e Seção

                Cad_Marca marca = new Cad_Marca();
                marca.id = AppFacade.get.reaproveitamento.getIncremento(dbXXX, typeof(Cad_Marca), 0);
                marca.idClienteFuncionarioLogado = 1;
                marca.marca = "GERAL";
                dbXXX.Store(marca);

                Cad_Secao secao = new Cad_Secao();
                secao.id = AppFacade.get.reaproveitamento.getIncremento(dbXXX, typeof(Cad_Secao), 0);
                secao.idClienteFuncionarioLogado = 1;
                secao.secao = "GERAL";
                secao.grupo = "GERAL";
                dbXXX.Store(secao);
                #endregion

                #region Pessoas

                //exportador normal
                /*
                Escreve("Escrevendo Pessoas");
                {
                    Empresa emp = ExportaEmpresas(dbXXX);
                    dbXXX.Store(emp);
                }
                 * */

                {
                    //propriedades
                    dr = readOdbc(Program.raizExportacao + "\\COMUM", "PROPRIED.DBF");
                    DataSet dtstProp = new DataSet();
                    dtstProp.Load(dr, LoadOption.OverwriteChanges, "tbl_propriedades");
                    dtProp = dtstProp.Tables[0];

                    dicPropri = new Dictionary<int, List<DataRow>>();
                    foreach (DataRow drow in dtProp.Rows)
                    {
                        if (drow["CLIE_PRO"] is Double)
                        {
                            int codigoCli = Convert.ToInt32(drow["CLIE_PRO"]);
                            if (!dicPropri.ContainsKey(codigoCli))
                                dicPropri[codigoCli] = new List<DataRow>();
                            dicPropri[codigoCli].Add(drow);
                        }
                    }
                }

                //exportador normal
                /*
                #region Clientes
                Escreve("Escrevendo Clientes");
                dr = readOdbc(Program.raizExportacao + "\\COMUM", "CLIENTES.DBF");
                ExportaClientes(dr, dbXXX);
                #endregion
                #region Fornecedores
                Escreve("Escrevendo Fornecedores");
                dr = readOdbc(Program.raizExportacao + "\\COMUM", "FORNECED.DBF");
                ExportaFornecedores(dr, dbXXX);
                #endregion
                 * */

                //exportador obra densa
                #region Fornecedores
                Escreve("Escrevendo Fornecedores");
                dr = readOdbc(Program.raizExportacao + "\\COMUM", "FORNECED.DBF");
                ExportaFornecedores(dr, dbXXX);
                #endregion
                #region Clientes
                Escreve("Escrevendo Clientes");
                dr = readOdbc(Program.raizExportacao + "\\COMUM", "CLIENTES.DBF");
                ExportaClientes(dr, dbXXX);
                #endregion

                Escreve("Escrevendo Pessoas");
                {
                    Empresa emp = ExportaEmpresas(dbXXX);
                    dbXXX.Store(emp);
                }

                /*
                //fiz isso pra inverter 1(UM) id do SDE para o cliente consumidor funcionar corretamente
                IQuery query = dbXXX.Query();
                query.Constrain(typeof(Cliente));
                IObjectSet rs_listaClientes = query.Execute();

                int indice = rs_listaClientes.Count - 2;

                Cliente clienteConsumidor = rs_listaClientes[indice] as Cliente;
                clienteConsumidor.id = 1;
                dbXXX.Store(clienteConsumidor);

                Cliente fornecedorBastardo = rs_listaClientes[0] as Cliente;
                clienteConsumidor.id = indice;
                dbXXX.Store(fornecedorBastardo);
                 * */

                #endregion

                #region Itens
                Escreve("Escrevendo Itens");
                dr = readOdbc(Program.raizExportacao + "\\DADOS1", "PRODUTOS.DBF");
                ExportaItens(dr, dbXXX);
                #endregion

                string cpf_cnpj_restringido = (novosCli[1] as Cliente).cpf_cnpj;
                int index = 0;

                List<Cliente> cEndList = new List<Cliente>();

                //retirei para testes na exportação obra densa
                /*
                foreach (Cliente cli in novosCli)
                {
                    if (cli.cpf_cnpj == cpf_cnpj_restringido && cli.id != 1)
                        index = novosCli.IndexOf(cli);

                    if (cli.__enderecos != null)
                    {
                        if (cli.id != 1 && cli.id != 2)
                            if (cli.__enderecos.Count == 0)
                            {
                                cEndList.Add(cli);
                                reprovadosCli.Add(cli);
                            }
                    }
                    else if (cli.id != 1 && cli.id != 2)
                    {
                        cEndList.Add(cli);
                        reprovadosCli.Add(cli);
                    }
                }
                 * */

                novosCli.RemoveAt(index);

                foreach (Cliente cEnd in cEndList)
                    novosCli.Remove(cEnd);

                foreach (Object o in novosCli)
                    dbXXX.Store(o);
                foreach (Object o in novosItem)
                    dbXXX.Store(o);

                Escreve("exportados:");
                Escreve("clientes: " + novosCli.Count.ToString());
                Escreve("produtos:" + novosItem.Count.ToString());
                Escreve("falhos:");
                Escreve("clientes: " + reprovadosCli.Count.ToString());
                Escreve("produtos:" + reprovadosItem.Count.ToString());

                dbXXX.Commit();
                dbXXX.Dispose();

                ZipFile zip = new ZipFile();
                zip.AddFile(arquivo);
                zip.Save(pastaExportacao + "\\dados_exportacao.zip");
                File.Delete(arquivo);

                arquivo = pastaExportacao + "\\1.Clientes.xml";
                using (TextWriter tw = new StreamWriter(arquivo + "_reprovados.xml"))
                {
                    new XmlSerializer(novosCli.GetType()).Serialize(tw, reprovadosCli);
                }
                arquivo = pastaExportacao + "\\2.Produtos.xml";
                using (TextWriter tw = new StreamWriter(arquivo + "_reprovados.xml"))
                {
                    new XmlSerializer(reprovadosItem.GetType()).Serialize(tw, reprovadosItem);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
                this.Close();
            }
        }
Ejemplo n.º 41
0
        /// <summary>
        /// Save the EPUB using Ionic zip library
        /// </summary>
        /// <param name="EpubFileName"></param>
        private void SaveEpubFile(String EpubFileName)
        {
            if (File.Exists(EpubFileName))
                File.Delete(EpubFileName);

            using (ZipFile zip = new ZipFile(EpubFileName))
            {
                // MUST save the 'mimetype' file as the first file and non-compressed
                zip.ForceNoCompression = true;
                zip.AddFile(Path.Combine(mainDir, "mimetype"), "");

                // Can compress all other files
                zip.ForceNoCompression = false;
                zip.AddDirectory(metaDir, "META-INF");
                zip.AddDirectory(opsDir, "OPS");

                zip.Save();
                Directory.Delete(mainDir, true);
                if (ddlType.Text == "Html")
                    if (workingFileName.ToLower() != tbxFileName.Text.ToLower())
                        File.Delete(workingFileName);
            }
        }
Ejemplo n.º 42
0
        private void UploadFiles(StringCollection files)
        {
            if (files.Count > 1 && (bool)Properties.Settings.Default["combinezip"])
            {
                string tempfile = Path.GetTempPath() + "\\qpaste.zip";
                File.Delete(tempfile);
                using (ZipFile zip = new ZipFile(tempfile))
                {
                    foreach (string file in files)
                    {
                        FileAttributes attr = File.GetAttributes(file);
                        if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
                        {
                            Debug.WriteLine(Path.GetFileName(file));
                            zip.AddDirectory(file, Path.GetFileName(file));
                        }
                        else
                        {
                            zip.AddFile(file, "");
                        }
                    }
                    zip.Save();
                }
                Token token = UploadHelper.getToken(tempfile);
                ClipboardHelper.PasteWithName("Multiple files", token.link);
                UploadHelper.Upload(tempfile, token);
                File.Delete(tempfile);
            }
            else
            {
                foreach (string file in files)
                {
                    Token token = null;

                    FileAttributes attr = File.GetAttributes(file);
                    if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
                    {
                        token = UploadHelper.getToken(file);
                        ClipboardHelper.PasteWithName(Path.GetFileName(file), token.link);

                        string tempfile = Path.GetTempPath() + "\\" + Path.GetFileNameWithoutExtension(file) + ".zip";
                        File.Delete(tempfile);
                        using (ZipFile zip = new ZipFile(tempfile))
                        {
                            zip.AddDirectory(file, "");
                            zip.Save();
                        }

                        UploadHelper.Upload(tempfile, token);
                        File.Delete(tempfile);
                    }
                    else
                    {
                        token = UploadHelper.getToken(file);
                        ClipboardHelper.PasteWithName(Path.GetFileName(file), token.link);

                        UploadHelper.Upload(file, token);
                    }
                }
            }
        }
Ejemplo n.º 43
0
 public static void GeneraOXT(Regles regles, string dirFitxer, string nomFitxer, CanviaString canvis)
 {
     // genera .oxt
     String path = dirFitxer + nomFitxer + ".oxt";
     File.Delete(path);
     using (ZipFile zip = new ZipFile(path))
     {
         zip.AddFile(dirFitxer + nomFitxer + ".dic", "dictionaries");
         zip.AddFile(dirFitxer + nomFitxer + ".aff", "dictionaries");
         zip.AddFile(dirFitxer + @"..\..\OXT\" + "LICENSES-en.txt","");
         zip.AddFile(dirFitxer + @"..\..\OXT\" + "LLICENCIES-ca.txt", "");
         zip.AddStringAsFile(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + nomFitxer + "\dictionaries.xcu", canvis, "\r\n", Encoding.UTF8), "dictionaries.xcu", "");
         zip.AddStringAsFile(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + nomFitxer + "\description.xml", canvis, "\r\n", Encoding.UTF8), "description.xml", "");
         //zip.AddStringAsFile(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + "release-notes_en.txt", canvia), "release-notes_en.txt", "");
         //zip.AddStringAsFile(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + "release-notes_ca.txt", canvia), "release-notes_ca.txt", "");
         zip.AddFile(dirFitxer + @"..\..\OXT\META-INF\" + "manifest.xml", "META-INF/");
         zip.AddFile(dirFitxer + @"..\..\OXT\" + "SC-logo.png","");
         zip.Save();
     }
     // genera update.xml, release-notes_en.txt i release-notes_ca.txt
     path = dirFitxer + nomFitxer + ".update.xml";
     using (StreamWriter sw = new StreamWriter(path, false, Encoding.UTF8)) {
         sw.Write(AdaptaFitxer(dirFitxer + @"..\..\OXT\update.xml", canvis, "\r\n", Encoding.UTF8));
     }
     string[] llengues = { "ca", "en" };
     foreach (string llengua in llengues)
     {
         path = dirFitxer + "release-notes_" + llengua + ".html";
         using (StreamWriter sw = new StreamWriter(path, false, Encoding.UTF8))
         {
             sw.Write(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + "release-notes_" + llengua + ".html", canvis, "\r\n", Encoding.UTF8));
         }
     }
 }
Ejemplo n.º 44
0
        public void Error_Save_NoFilename()
        {
            string testBin = TestUtilities.GetTestBinDir(CurrentDir);
            string resourceDir = Path.Combine(testBin, "Resources");
            Directory.SetCurrentDirectory(TopLevelDir);
            string filename = Path.Combine(resourceDir, "TestStrings.txt");
            Assert.IsTrue(File.Exists(filename), String.Format("The file '{0}' doesnot exist.", filename));

            // add an entry to the zipfile, then try saving, never having specified a filename. This should fail.
            using (ZipFile zip = new ZipFile())
            {
                zip.AddFile(filename, "");
                zip.Save(); // FAIL: don't know where to save!
            }

            // should never reach this
            Assert.IsTrue(false);
        }
Ejemplo n.º 45
0
        protected void btnDownloadQuickStatsGadget_Click(object sender, EventArgs e)
        {
            string gadgetFile = Server.MapPath("~/Temp/" + Config.Misc.GadgetsPrefix + " " +
                ((PageBase)Page).CurrentUserSession.Username + " Quick Stats.gadget");
            if (File.Exists(gadgetFile)) File.Delete(gadgetFile);

            using (ZipFile zip = new ZipFile(gadgetFile))
            {
                zip.BaseDir = Config.Directories.Home + @"\Gadgets\QuickStats\gadget\";
                string[] filenames = Directory.GetFiles(Config.Directories.Home + @"\Gadgets\QuickStats\gadget");
                foreach (String filename in filenames)
                {
                    ZipEntry.FileParserDelegate parser = null;

                    if (filename.Contains("gadget.htm"))
                        parser = new ZipEntry.FileParserDelegate(QuickStatsGadgetParser);

                    zip.AddFile(filename, false, parser);
                }

                zip.Save();
            }

            Response.Clear();
            Response.AppendHeader("content-disposition",
                                  String.Format("attachment; filename=\"{0}.gadget\"",
                                                string.Format("{0} Quick Stats".Translate(), Config.Misc.GadgetsPrefix)));
            Response.TransmitFile(gadgetFile);
            Response.End();
        }
Ejemplo n.º 46
0
        [ExpectedException(typeof(ZipException))] // not sure which exception - could be one of several.
        public void Error_ReadCorruptedZipFile_Passwords()
        {
            string zipFileToCreate = Path.Combine(TopLevelDir, "Read_CorruptedZipFile_Passwords.zip");
            string sourceDir = CurrentDir;
            for (int i = 0; i < 3; i++)
                sourceDir = Path.GetDirectoryName(sourceDir);

            Directory.SetCurrentDirectory(TopLevelDir);

            // the list of filenames to add to the zip
            string[] filenames =
            {
                Path.Combine(sourceDir, "Tools\\Zipit\\bin\\Debug\\Zipit.exe"),
                Path.Combine(sourceDir, "Zip\\bin\\Debug\\Ionic.Zip.xml"),
                Path.Combine(sourceDir, "Tools\\WinFormsApp\\Icon2.res"),
            };

            // passwords to use for those entries
            string[] passwords = { "12345678", "0987654321", };

            // create the zipfile, adding the files
            int j = 0;
            using (ZipFile zip = new ZipFile())
            {
                for (j = 0; j < filenames.Length; j++)
                {
                    zip.Password = passwords[j % passwords.Length];
                    zip.AddFile(filenames[j], "");
                }
                zip.Save(zipFileToCreate);
            }

            IntroduceCorruption(zipFileToCreate);

            try
            {
                // read the corrupted zip - this should fail in some way
                using (ZipFile zip = ZipFile.Read(zipFileToCreate))
                {
                    for (j = 0; j < filenames.Length; j++)
                    {
                        ZipEntry e = zip[Path.GetFileName(filenames[j])];

                        System.Console.WriteLine("name: {0}  compressed: {1} has password?: {2}",
                            e.FileName, e.CompressedSize, e.UsesEncryption);
                        Assert.IsTrue(e.UsesEncryption, "The entry does not use encryption");
                        e.ExtractWithPassword("unpack", passwords[j % passwords.Length]);
                    }
                }
            }
            catch (Exception exc1)
            {
                throw new ZipException("expected", exc1);
            }
        }
Ejemplo n.º 47
0
        public void Password_Extract_WrongPassword()
        {
            string ZipFileToCreate = Path.Combine(TopLevelDir, "MultipleEntriesDifferentPasswords.zip");
            Assert.IsFalse(File.Exists(ZipFileToCreate), "The temporary zip file '{0}' already exists.", ZipFileToCreate);

            string SourceDir = CurrentDir;
            for (int i = 0; i < 3; i++)
                SourceDir = Path.GetDirectoryName(SourceDir);

            Directory.SetCurrentDirectory(TopLevelDir);

            string[] filenames =
            {
                Path.Combine(SourceDir, "Tools\\Zipit\\bin\\Debug\\Zipit.exe"),
                Path.Combine(SourceDir, "Zip\\bin\\Debug\\Ionic.Zip.xml"),
            };

            string[] passwords =
            {
                    "12345678",
                    "0987654321",
            };

            int j = 0;
            using (ZipFile zip = new ZipFile(ZipFileToCreate))
            {
                for (j = 0; j < filenames.Length; j++)
                {
                    zip.Password = passwords[j];
                    zip.AddFile(filenames[j], "");
                }
                zip.Save();
            }

            // now try to extract
            using (ZipFile zip = new ZipFile(ZipFileToCreate))
            {
                for (j = 0; j < filenames.Length; j++)
                    zip[Path.GetFileName(filenames[j])].ExtractWithPassword("unpack", ExtractExistingFileAction.OverwriteSilently, "WrongPassword");
            }
        }
Ejemplo n.º 48
0
        public void Error_LockedFile_wi13903()
        {
            TestContext.WriteLine("==Error_LockedFile_wi13903()");
            string fname = Path.GetRandomFileName();
            TestContext.WriteLine("create file {0}", fname);
            TestUtilities.CreateAndFillFileText(fname, _rnd.Next(10000) + 5000);
            string zipFileToCreate = "wi13903.zip";

            var zipErrorHandler = new EventHandler<ZipErrorEventArgs>( (sender, e)  =>
                {
                    TestContext.WriteLine("Error reading entry {0}", e.CurrentEntry);
                    TestContext.WriteLine("  (this was expected)");
                    e.CurrentEntry.ZipErrorAction = ZipErrorAction.Skip;
                });

            // lock the file
            TestContext.WriteLine("lock file {0}", fname);
            using (var s = System.IO.File.Open(fname,
                                               FileMode.Open,
                                               FileAccess.Read,
                                               FileShare.None))
            {
                using (var rawOut = File.Create(zipFileToCreate))
                {
                    using (var nonSeekableOut = new Ionic.Zip.Tests.NonSeekableOutputStream(rawOut))
                    {
                        TestContext.WriteLine("create zip file {0}", zipFileToCreate);
                        using (var zip = new ZipFile())
                        {
                            zip.ZipError += zipErrorHandler;
                            zip.AddFile(fname);
                            // should trigger a read error,
                            // which should be skipped. Result will be
                            // a zero-entry zip file.
                            zip.Save(nonSeekableOut);
                        }
                    }
                }
            }
            TestContext.WriteLine("all done, A-OK");
        }
Ejemplo n.º 49
0
        /////////////////////////////////////////////////////
        //                                                 //
        // DoCollect()                                     //
        //                                                 //
        /////////////////////////////////////////////////////
        //Description:  Collects all files identified in the scan
        //              as malicious and stuffs them into a
        //              password-protected, encrypted ZIP file.
        //
        //              NOTE:  depends on DoSignatureScan()
        //
        //
        //Returns:      true if successful
        //////////////////////////////////////////////////////
        private unsafe bool DoCollect()
        {
            AgentScanLog.AppendLine("");
            AgentScanLog.AppendLine("*********************************************");
            AgentScanLog.AppendLine("                  COLLECT                    ");
            AgentScanLog.AppendLine("*********************************************");
            AgentScanLog.AppendLine("");
            AgentScanLog.AppendLine("COLLECT:  Collecting evidence files...");

            //collect the following files to wrap up in archive file:
            //  1. all identified malware files
            //  2. infection log (Infection_Log.txt) which we create
            //  3. usb device list file (USB_Devices.txt) which we create
            //  4. .net installation log (if exists)
            //

            //---------------------------------
            //          BUILD ZIP NAME
            //---------------------------------
            ZipFileName = Collect.BuildZipName(TotalFindingsCount);
            ZipFile zip = new ZipFile(ZipFileName);

            if (AgentSettings.ContainsKey("Reporting_Archive_Password"))
            {
                IntPtr pptr = IntPtr.Zero;
                //do this secure string thing if password specified
                char[] str = AgentSettings["Reporting_Archive_Password"].ToCharArray();

                fixed (char* pChars = str)
                {
                    ZipPassword = new SecureString(pChars, str.Length);
                }

                //decrypt our password in memory
                pptr = Marshal.SecureStringToBSTR(ZipPassword);
                zip.Password = Marshal.PtrToStringBSTR(pptr);

                //zero the password memory
                Marshal.ZeroFreeBSTR(pptr);
            }

            zip.TempFileFolder = ".";
            ArrayList CollectList = new ArrayList();
            int count = 0;

            AgentScanLog.AppendLine("COLLECT:  Searching file signature matches for files...");

            //loop through file signatures
            foreach (CwXML.FileSignatureMatch fileMatch in AgentSignatureMatches.FileSignatureMatches)
                if (Collect.AddToZip(zip, fileMatch.FullPath))
                    count++;

            AgentScanLog.AppendLine("COLLECT:  Added " + count + " files.");
            count = 0;
            AgentScanLog.AppendLine("COLLECT:  Searching registry signature matches for files...");

            //loop through registry signatures
            foreach (CwXML.RegistrySignatureMatch registryMatch in AgentSignatureMatches.RegistrySignatureMatches)
                if (registryMatch.IsFileOnDisk)
                    if (Collect.AddToZip(zip, registryMatch.RegistryValueData))
                        count++;

            AgentScanLog.AppendLine("COLLECT:  Added " + count + " files.");
            AgentScanLog.AppendLine("COLLECT:  Generating infection summary report...");

            //---------------------------------
            //          ADD INFECTION LOG
            //---------------------------------
            //2.  infection log (Infection_Log.txt) which we create
            StreamWriter infectionlog = new StreamWriter("InfectionLog.txt");
            StringBuilder InfectionSummaryReport = new StringBuilder();

            //print infection summary for each signature type
            RegistryHelper RegHelper = new RegistryHelper();
            FileHelper FileHelper = new FileHelper();
            MemoryHelper MemHelper = new MemoryHelper();
            RegHelper.PrintRegistryFindings(AgentSignatureMatches.RegistrySignatureMatches, ref InfectionSummaryReport);
            FileHelper.PrintFileFindings(AgentSignatureMatches.FileSignatureMatches, ref InfectionSummaryReport);
            MemHelper.PrintMemoryFindings(AgentSignatureMatches.MemorySignatureMatches, ref InfectionSummaryReport);
            infectionlog.WriteLine(InfectionSummaryReport.ToString());
            infectionlog.Close();
            zip.AddFile("InfectionLog.txt");

            AgentScanLog.AppendLine("COLLECT:  Enumerating USB Devices...");

            //---------------------------------
            //          ADD USB DEVICES LOG
            //---------------------------------
            //3.  usb device list file (USB_Devices.txt) which we create
            StreamWriter usblogfile = new StreamWriter("USB_Devices.txt");
            StringBuilder UsbDevicesReport = new StringBuilder();
            Collect.EnumerateUSBDevices(ref UsbDevicesReport);
            usblogfile.WriteLine(UsbDevicesReport.ToString());
            usblogfile.Close();
            zip.AddFile("USB_Devices.txt");

            //---------------------------------
            //          ADD .NET LOG
            //---------------------------------
            //4.  .net installation log (if exists)
            try
            {
                FileInfo dotnetfxLogfile = new FileInfo("dotnetfx_install_log.txt");
                if (dotnetfxLogfile.Exists)
                    zip.AddFile("dotnetfx_install_log.txt");
            }
            catch { } //no biggie..

            AgentScanLog.AppendLine("COLLECT:  All evidence collected.");
            AgentScanLog.AppendLine("COLLECT:  Saving zip to disk...");
            zip.Save();
            zip.Dispose();  //at this point zip is closed and written to disk

            return true;
        }
Ejemplo n.º 50
0
        public void Password_MultipleEntriesDifferentPasswords()
        {
            string ZipFileToCreate = Path.Combine(TopLevelDir, "Password_MultipleEntriesDifferentPasswords.zip");
            Assert.IsFalse(File.Exists(ZipFileToCreate), "The temporary zip file '{0}' already exists.", ZipFileToCreate);

            string SourceDir = CurrentDir;
            for (int i = 0; i < 3; i++)
                SourceDir = Path.GetDirectoryName(SourceDir);

            Directory.SetCurrentDirectory(TopLevelDir);

            string[] filenames =
            {
                Path.Combine(SourceDir, "Tools\\Zipit\\bin\\Debug\\Zipit.exe"),
                Path.Combine(SourceDir, "Zip\\bin\\Debug\\Ionic.Zip.xml"),
            };

            string[] checksums =
            {
                TestUtilities.GetCheckSumString(filenames[0]),
                TestUtilities.GetCheckSumString(filenames[1]),
            };

            string[] passwords =
            {
                    "12345678",
                    "0987654321",
            };

            int j = 0;
            using (ZipFile zip = new ZipFile(ZipFileToCreate))
            {
                for (j = 0; j < filenames.Length; j++)
                {
                    zip.Password = passwords[j];
                    zip.AddFile(filenames[j], "");
                }
                zip.Save();
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(ZipFileToCreate), filenames.Length,
                    "The zip file created has the wrong number of entries.");

            using (ZipFile zip = new ZipFile(ZipFileToCreate))
            {
                for (j = 0; j < filenames.Length; j++)
                {
                    zip[Path.GetFileName(filenames[j])].ExtractWithPassword("unpack", ExtractExistingFileAction.OverwriteSilently, passwords[j]);
                    string newpath = Path.Combine("unpack", filenames[j]);
                    string chk = TestUtilities.GetCheckSumString(newpath);
                    Assert.AreEqual<string>(checksums[j], chk, "File checksums do not match.");
                }
            }
        }
Ejemplo n.º 51
0
 public static void ZipFiles(IEnumerable<string> fileNames, string targetFile)
 {
     ZipFile zipedFile = new ZipFile();
     foreach (string file in fileNames)
     {
         zipedFile.AddFile(file, String.Empty);
     }
     zipedFile.Save(targetFile);
 }
Ejemplo n.º 52
0
        public void Password_AddEntryWithPasswordToExistingZip()
        {
            string zipFileToCreate = "AddEntryWithPasswordToExistingZip.zip";
            string dnzDir = CurrentDir;
            for (int i = 0; i < 3; i++)
                dnzDir = Path.GetDirectoryName(dnzDir);

            string[] filenames =
            {
                Path.Combine(dnzDir, "Tools\\Zipit\\bin\\Debug\\Zipit.exe"),
                Path.Combine(dnzDir, "Zip\\bin\\Debug\\Ionic.Zip.xml"),
            };

            string[] checksums =
            {
                TestUtilities.GetCheckSumString(filenames[0]),
                TestUtilities.GetCheckSumString(filenames[1]),
            };

            int j = 0;
            using (ZipFile zip = new ZipFile(zipFileToCreate))
            {
                for (j = 0; j < filenames.Length; j++)
                    zip.AddFile(filenames[j], "");
                zip.Save();
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 2,
                    "wrong number of entries.");

            string fileX = Path.Combine(dnzDir, "Tools\\Unzip\\bin\\debug\\unzip.exe");
            string checksumX = TestUtilities.GetCheckSumString(fileX);
            string password = TestUtilities.GenerateRandomPassword() + "!";
            using (ZipFile zip = new ZipFile(zipFileToCreate))
            {
                zip.Password = password;
                zip.AddFile(fileX, "");
                zip.Save();
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 3,
                    "wrong number of entries.");

            string unpackDir = "unpack";
            string newpath, chk, baseName;
            using (ZipFile zip = new ZipFile(zipFileToCreate))
            {
                for (j = 0; j < filenames.Length; j++)
                {
                    baseName = Path.GetFileName(filenames[j]);
                    zip[baseName].Extract(unpackDir, ExtractExistingFileAction.OverwriteSilently);
                    newpath = Path.Combine(unpackDir, filenames[j]);
                    chk = TestUtilities.GetCheckSumString(newpath);
                    Assert.AreEqual<string>(checksums[j], chk, "Checksums do not match.");
                }

                baseName = Path.GetFileName(fileX);

                zip[baseName].ExtractWithPassword(unpackDir,
                                                  ExtractExistingFileAction.OverwriteSilently,
                                                  password);

                newpath = Path.Combine(unpackDir, fileX);
                chk = TestUtilities.GetCheckSumString(newpath);
                Assert.AreEqual<string>(checksumX, chk, "Checksums do not match.");
            }
        }
Ejemplo n.º 53
0
        protected void btnGenerateAdminStatsGadget_Click(object sender, EventArgs e)
        {
            if (!HasWriteAccess)
                return;

            string gadgetFile = Path.GetTempPath() + Config.Misc.GadgetsPrefix + " Admin Stats.gadget";
            if (File.Exists(gadgetFile)) File.Delete(gadgetFile);

            using (ZipFile zip = new ZipFile(gadgetFile))
            {
                zip.BaseDir = Config.Directories.Home + @"\Gadgets\AdminStats\gadget\";
                string[] filenames = Directory.GetFiles(Config.Directories.Home + @"\Gadgets\AdminStats\gadget");
                foreach (String filename in filenames)
                {
                    ZipEntry.FileParserDelegate parser = null;
                    
                    if (filename.Contains("gadget.htm"))
                        parser = new ZipEntry.FileParserDelegate(FileParser);

                    zip.AddFile(filename, false, parser);
                }

                zip.Save();
            }

            Response.Clear();
            Response.AppendHeader("content-disposition",
                                  String.Format("attachment; filename=\"{0}.gadget\"",
                                                Config.Misc.GadgetsPrefix + " Admin Stats"));
            Response.TransmitFile(gadgetFile);
            Response.End();
        }