Exemple #1
0
// zipOpen returns a zipReadCloser.
func (b *Bundle) zipOpen() (*zipReadCloser, error) {
	// If we don't have a Path, try to use the original ReaderAt.
	if b.Path == "" {
		r, err := zip.NewReader(b.r, b.size)
		if err != nil {
			return nil, err
		}
		return &zipReadCloser{Closer: ioutil.NopCloser(nil), Reader: r}, nil
	}
	f, err := os.Open(b.Path)
	if err != nil {
		return nil, err
	}
	fi, err := f.Stat()
	if err != nil {
		f.Close()
		return nil, err
	}
	r, err := zip.NewReader(f, fi.Size())
	if err != nil {
		f.Close()
		return nil, err
	}
	return &zipReadCloser{Closer: f, Reader: r}, nil
}
Exemple #2
0
// zipExeReaderElf treats the file as a ELF binary
// (linux/BSD/etc... executable) and attempts to find a zip archive.
func zipExeReaderElf(rda io.ReaderAt, size int64) (*zip.Reader, error) {
	file, err := elf.NewFile(rda)
	if err != nil {
		return nil, err
	}

	var max int64
	for _, sect := range file.Sections {
		if sect.Type == elf.SHT_NOBITS {
			continue
		}

		// Check if this section has a zip file
		if zfile, err := zip.NewReader(sect, int64(sect.Size)); err == nil {
			return zfile, nil
		}

		// Otherwise move end of file pointer
		end := int64(sect.Offset + sect.Size)
		if end > max {
			max = end
		}
	}

	// No zip file within binary, try appended to end
	section := io.NewSectionReader(rda, max, size-max)
	return zip.NewReader(section, section.Size())
}
Exemple #3
0
func ProcessDiff(fname string, data1, data2 []byte, brief bool, skips string) (DiffResult, error) {
	diffResult := DiffResult{}
	diffResult.Title = fmt.Sprintf("ファイル %s は異なります", fname)
	if brief {
		return diffResult, nil
	}
	if isSkiping(fname, skips) {
		return diffResult, nil
	}
	if strings.HasSuffix(fname, "jar") || strings.HasSuffix(fname, "war") || strings.HasSuffix(fname, "zip") {
		diffResult.IsZip = true
		zipa, err := zip.NewReader(bytes.NewReader(data1), int64(len(data1)))
		if err != nil {
			return diffResult, err
		}
		zipb, err := zip.NewReader(bytes.NewReader(data2), int64(len(data2)))
		if err != nil {
			return diffResult, err
		}
		var buf bytes.Buffer
		DisplayAsText(&buf, ZipDiffContent(zipa, zipb, brief, skips))
		diffResult.Diff = buf.String()
	} else if strings.HasSuffix(fname, "class") {
		diffResult.Diff = godiff(string(jadfile(data1)), string(jadfile(data2)))
	} else if checkBinary(data1) {
		diffResult.IsBinary = true
	} else {
		diffResult.Diff = godiff(string(data1), string(data2))
	}
	return diffResult, nil
}
Exemple #4
0
// zipExeReaderMacho treats the file as a Mach-O binary
// (Mac OS X / Darwin executable) and attempts to find a zip archive.
func zipExeReaderMacho(rda io.ReaderAt, size int64) (*zip.Reader, error) {
	file, err := macho.NewFile(rda)
	if err != nil {
		return nil, err
	}

	var max int64
	for _, load := range file.Loads {
		seg, ok := load.(*macho.Segment)
		if ok {
			// Check if the segment contains a zip file
			if zfile, err := zip.NewReader(seg, int64(seg.Filesz)); err == nil {
				return zfile, nil
			}

			// Otherwise move end of file pointer
			end := int64(seg.Offset + seg.Filesz)
			if end > max {
				max = end
			}
		}
	}

	// No zip file within binary, try appended to end
	section := io.NewSectionReader(rda, max, size-max)
	return zip.NewReader(section, section.Size())
}
Exemple #5
0
func fetchZip(zipurl string) (*zip.Reader, error) {
	req, err := http.NewRequest("GET", zipurl, nil)
	if err != nil {
		return nil, err
	}

	req.Header.Set("User-Agent", userAgent)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		b, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			return nil, errors.New(resp.Status)
		}
		return nil, errors.New(string(b))
	}

	buf := &bytes.Buffer{}

	_, err = io.Copy(buf, resp.Body)
	if err != nil {
		return nil, err
	}

	b := bytes.NewReader(buf.Bytes())
	return zip.NewReader(b, int64(b.Len()))
}
Exemple #6
0
func (hra *HttpReaderAt) ReadZip() error {
	reader, err := zip.NewReader(hra, hra.ContentLength)
	if err != nil {
		return err
	}
	for _, zf := range reader.File {
		if hra.Verbose {
			fmt.Printf("%s\n", zf.Name)
		}
		err = CreateParents(zf.Name)
		if err != nil {
			fmt.Println(err)
			continue
		}
		f, err := os.Create(zf.Name)
		if err != nil {
			fmt.Println(err)
			continue
		}
		rc, err := zf.Open()
		if err != nil {
			fmt.Println(err)
			continue
		}
		go WriteAllAndClose(rc, f)
	}
	return nil
}
Exemple #7
0
// WalkAny tries to retrieve container information on containerPath. It supports:
// the empty container (/dev/null), local directories, zip archives
func WalkAny(containerPath string, filter FilterFunc) (*Container, error) {
	// empty container case
	if containerPath == NullPath {
		return &Container{}, nil
	}

	file, err := eos.Open(containerPath)
	if err != nil {
		return nil, errors.Wrap(err, 1)
	}

	defer file.Close()

	stat, err := file.Stat()
	if err != nil {
		return nil, errors.Wrap(err, 1)
	}

	if stat.IsDir() {
		if err != nil {
			return nil, errors.Wrap(err, 1)
		}

		// local directory case
		return WalkDir(containerPath, filter)
	}

	// zip archive case
	zr, err := zip.NewReader(file, stat.Size())
	if err != nil {
		return nil, errors.Wrap(err, 1)
	}

	return WalkZip(zr, filter)
}
Exemple #8
0
func (s *S) TestGetArchiveIntegrationWhenInvalidFormat(c *gocheck.C) {
	expected := make(map[string]string)
	expected["gandalf-test-repo-master/README"] = "much WOW"
	oldBare := bare
	bare = "/tmp"
	repo := "gandalf-test-repo"
	file := "README"
	content := "much WOW"
	cleanUp, errCreate := CreateTestRepository(bare, repo, file, content)
	defer func() {
		cleanUp()
		bare = oldBare
	}()
	c.Assert(errCreate, gocheck.IsNil)
	zipContents, err := GetArchive(repo, "master", 99)
	reader := bytes.NewReader(zipContents)
	zipReader, err := zip.NewReader(reader, int64(len(zipContents)))
	c.Assert(err, gocheck.IsNil)
	for _, f := range zipReader.File {
		//fmt.Printf("Contents of %s:\n", f.Name)
		rc, err := f.Open()
		c.Assert(err, gocheck.IsNil)
		defer rc.Close()
		contents, err := ioutil.ReadAll(rc)
		c.Assert(err, gocheck.IsNil)
		c.Assert(string(contents), gocheck.Equals, expected[f.Name])
	}
}
Exemple #9
0
func installZip(source *bytes.Reader, dest string) error {
	zr, err := zip.NewReader(source, int64(source.Len()))
	if err != nil {
		return err
	}

	for _, f := range zr.File {
		fileCopy, err := os.OpenFile(dest, installFlag, f.Mode())
		if err != nil {
			return err
		}
		defer fileCopy.Close()

		rc, err := f.Open()
		if err != nil {
			return err
		}
		defer rc.Close()

		_, err = io.Copy(fileCopy, rc)
		if err != nil {
			return err
		}
	}

	return nil
}
Exemple #10
0
func extractFpUtil(archive []byte) {
	zipReader, err := zip.NewReader(bytes.NewReader(archive), int64(len(archive)))
	if err != nil {
		utils.Log(utils.ERROR, "recognizer.extractFpUtil: failed to unzip fingerprint util archive: %v", err)
		return
	}

	for _, file := range zipReader.File {
		if len(file.Name) < len(fpUtil()) || file.Name[len(file.Name)-len(fpUtil()):] != fpUtil() {
			continue
		}

		src, err := file.Open()
		if err != nil {
			utils.Log(utils.ERROR, "recognizer.extractFpUtil: failed to extract fingerprint util from archive: %v", err)
			return
		}
		defer src.Close()

		dst, err := os.OpenFile(pathToFpUtil(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755)
		if err != nil {
			utils.Log(utils.ERROR, "recognizer.extractFpUtil: failed to open file '%v' for writing: %v", pathToFpUtil(), err)
			return
		}
		defer dst.Close()

		if _, err := io.Copy(dst, src); err != nil {
			utils.Log(utils.ERROR, "recognizer.extractFpUtil: failed to save fingerprint util to '%v': %v", pathToFpUtil(), err)
			return
		}

		break
	}
}
Exemple #11
0
func unpackZip(dest string, r *os.File) error {
	stat, err := r.Stat()
	if err != nil {
		return err
	}
	zr, err := zip.NewReader(r, stat.Size())
	if err != nil {
		return err
	}
	for _, f := range zr.File {
		if strings.HasSuffix(f.Name, "/") {
			continue
		}
		fr, err := f.Open()
		if err != nil {
			return err
		}
		err = unpackFile(dest, fr, f.Name, f.Mode())
		fr.Close()
		if err != nil {
			return err
		}
	}
	return nil
}
Exemple #12
0
// setups state each of the tests uses
func setup() error {
	// create zipfs
	b := new(bytes.Buffer)
	zw := zip.NewWriter(b)
	for file, contents := range files {
		w, err := zw.Create(file)
		if err != nil {
			return err
		}
		_, err = io.WriteString(w, contents)
		if err != nil {
			return err
		}
	}
	zw.Close()
	zr, err := zip.NewReader(bytes.NewReader(b.Bytes()), int64(b.Len()))
	if err != nil {
		return err
	}
	rc := &zip.ReadCloser{
		Reader: *zr,
	}
	fs = New(rc, "foo")

	// pull out different stat functions
	statFuncs = []statFunc{
		{"Stat", fs.Stat},
		{"Lstat", fs.Lstat},
	}

	return nil
}
func getLatestVersion(zipFile []byte, prefix, suffix string) (string, error) {
	r, err := zip.NewReader(bytes.NewReader(zipFile), int64(len(zipFile)))
	if err != nil {
		return "", err
	}
	latest := ""
	for _, f := range r.File {
		artifact := path.Base(f.Name)
		if strings.HasPrefix(artifact, prefix) && strings.HasSuffix(artifact, suffix) {
			v := extractVersion(artifact)
			if latest == "" {
				latest = v
			}
			v1, err := semver.Parse(v)
			if err != nil {
				return "", err
			}
			l := semver.MustParse(latest)
			if v1.GT(l) {
				latest = v
			}
		}
	}
	return latest, nil
}
func (s *S) TestCopyZipFile(c *gocheck.C) {
	tempDir, err := ioutil.TempDir("", "TestCopyZipFileDir")
	defer func() {
		os.RemoveAll(tempDir)
	}()
	c.Assert(err, gocheck.IsNil)
	var files = []File{
		{"doge.txt", "Much doge"},
		{"much.txt", "Much mucho"},
		{"WOW/WOW.WOW1", "WOW\nWOW"},
		{"WOW/WOW.WOW2", "WOW\nWOW"},
		{"/usr/WOW/WOW.WOW3", "WOW\nWOW"},
		{"/usr/WOW/WOW.WOW4", "WOW\nWOW"},
	}
	buf, err := CreateZipBuffer(files)
	c.Assert(err, gocheck.IsNil)
	c.Assert(buf, gocheck.NotNil)
	r, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
	for _, f := range r.File {
		err = CopyZipFile(f, tempDir, f.Name)
		c.Assert(err, gocheck.IsNil)
		fstat, errStat := os.Stat(path.Join(tempDir, f.Name))
		c.Assert(errStat, gocheck.IsNil)
		c.Assert(fstat.IsDir(), gocheck.Equals, false)
	}
}
Exemple #15
0
func (t *unzip) Execute() error {
	zipFile, err := os.Open(t.zipFileName)
	if err != nil {
		return makeError("opening file '"+t.zipFileName+"'", err)
	}
	defer zipFile.Close()

	info, err := zipFile.Stat()
	if err != nil {
		return makeError("reading file info of '"+zipFile.Name()+"'", err)
	}

	zipReader, err := zip.NewReader(zipFile, info.Size())
	if err != nil {
		return makeError("creating zip file reader for '"+zipFile.Name()+"'", err)
	}

	for _, f := range zipReader.File {
		destPath := filepath.Join(t.path, filepath.FromSlash(f.Name))
		if f.FileInfo().IsDir() {
			if err := os.MkdirAll(destPath, 0666); err != nil {
				return makeError("creating path to folder '"+destPath+"'", err)
			}
		} else {
			if err := copyFile(f, destPath); err != nil {
				return makeError(
					"copying zip file '"+f.Name+"' data to file '"+destPath+"'",
					err)
			}
		}
	}

	return nil
}
Exemple #16
0
func TestZipWithDirectory(t *testing.T) {
	dir, err := os.Getwd()
	assert.NoError(t, err)

	zipper := ApplicationZipper{}
	zipFile, err := zipper.Zip(filepath.Clean(dir + "/../fixtures/zip/"))
	assert.NoError(t, err)

	byteReader := bytes.NewReader(zipFile.Bytes())
	reader, err := zip.NewReader(byteReader, int64(byteReader.Len()))
	assert.NoError(t, err)

	readFile := func(index int) (string, string) {
		buf := &bytes.Buffer{}
		file := reader.File[index]
		fReader, err := file.Open()
		_, err = io.Copy(buf, fReader)

		assert.NoError(t, err)

		return file.Name, string(buf.Bytes())
	}

	assert.Equal(t, len(reader.File), 2)

	name, contents := readFile(0)
	assert.Equal(t, name, "foo.txt")
	assert.Equal(t, contents, "This is a simple text file.")

	name, contents = readFile(1)
	assert.Equal(t, name, "subDir/bar.txt")
	assert.Equal(t, contents, "I am in a subdirectory.")
}
func uploadBuildpackRequest(filename string) testnet.TestRequest {
	return testnet.TestRequest{
		Method: "PUT",
		Path:   "/v2/buildpacks/my-cool-buildpack-guid/bits",
		Response: testnet.TestResponse{
			Status: http.StatusCreated,
			Body:   `{ "metadata":{ "guid": "my-job-guid" } }`,
		},
		Matcher: func(request *http.Request) {
			err := request.ParseMultipartForm(4096)
			defer request.MultipartForm.RemoveAll()
			Expect(err).NotTo(HaveOccurred())

			Expect(len(request.MultipartForm.Value)).To(Equal(0))
			Expect(len(request.MultipartForm.File)).To(Equal(1))

			files, ok := request.MultipartForm.File["buildpack"]
			Expect(ok).To(BeTrue(), "Buildpack file part not present")
			Expect(len(files)).To(Equal(1), "Wrong number of files")

			buildpackFile := files[0]
			Expect(buildpackFile.Filename).To(Equal(filepath.Base(filename)), "Wrong file name")

			file, err := buildpackFile.Open()
			Expect(err).NotTo(HaveOccurred())

			zipReader, err := zip.NewReader(file, 4096)
			Expect(err).NotTo(HaveOccurred())

			actualFileNames := []string{}
			actualFileContents := []string{}
			for _, f := range zipReader.File {
				actualFileNames = append(actualFileNames, f.Name)
				c, _ := f.Open()
				content, _ := ioutil.ReadAll(c)
				actualFileContents = append(actualFileContents, string(content))
			}
			sort.Strings(actualFileNames)

			Expect(actualFileNames).To(Equal([]string{
				"bin/compile",
				"bin/detect",
				"bin/release",
				"lib/helper",
			}))
			Expect(actualFileContents).To(Equal([]string{
				"the-compile-script\n",
				"the-detect-script\n",
				"the-release-script\n",
				"the-helper-script\n",
			}))

			if runtime.GOOS != "windows" {
				Expect(zipReader.File[0].Mode()).To(Equal(os.FileMode(0755)))
				Expect(zipReader.File[1].Mode()).To(Equal(os.FileMode(0755)))
				Expect(zipReader.File[2].Mode()).To(Equal(os.FileMode(0755)))
			}
		},
	}
}
Exemple #18
0
func GetFileFromZip(file io.ReaderAt, size int64, subFile string) []byte {
	r, err := zip.NewReader(file, size)
	if err != nil {
		log.Fatal(err)
	}

	// Iterate through the files in the archive,
	// printing some of their contents.
	for _, f := range r.File {
		if f.Name == subFile {
			var body []byte
			rc, err := f.Open()
			if err != nil {
				log.Fatal(err)
			}
			body, err = ioutil.ReadAll(rc)
			if err != nil {
				log.Fatal(err)
			}
			rc.Close()

			return body
		}
	}
	return []byte{}
}
Exemple #19
0
func installTerminalNotifier() error {
	baseRootPath := filepath.Join(os.TempDir(), tempDirSuffix)
	rootPath = filepath.Join(baseRootPath, zipNameSuffix)

	//if terminal-notifier.app already installed no-need to re-install
	if exists(filepath.Join(rootPath, executablePath)) {
		return nil
	}
	buf := bytes.NewReader(terminalnotifier())
	reader, err := zip.NewReader(buf, int64(buf.Len()))
	if err != nil {
		return err
	}
	err = unpackZip(reader, baseRootPath)
	if err != nil {
		return fmt.Errorf("could not unpack zip terminal-notifier file: %s", err)
	}

	err = os.Chmod(filepath.Join(rootPath, executablePath), 0755)
	if err != nil {
		return fmt.Errorf("could not make terminal-notifier executable: %s", err)
	}

	return nil
}
Exemple #20
0
func loadMap() (map[string]Resource, error) {
	this := os.Args[0]
	file, err := os.Open(this)
	if err != nil {
		return nil, err
	}

	info, err := file.Stat()
	if err != nil {
		return nil, err
	}
	rdr, err := zip.NewReader(file, info.Size())
	if err != nil {
		return nil, err
	}

	entries := make(map[string]Resource)
	for _, file := range rdr.File {
		if file.FileInfo().IsDir() {
			continue
		}
		entries[file.Name] = &resource{file}
	}

	return entries, nil
}
Exemple #21
0
func downloadFile(pluginName, filePath, url string) (err error) {
	defer func() {
		if r := recover(); r != nil {
			retryCount++
			if retryCount < 3 {
				fmt.Println("Failed downloading. Will retry once.")
				err = downloadFile(pluginName, filePath, url)
			} else {
				failure := fmt.Sprintf("%v", r)
				if failure == "runtime error: makeslice: len out of range" {
					err = fmt.Errorf("Corrupt http response from source. Please try again.\n")
				} else {
					panic(r)
				}
			}
		}
	}()

	resp, err := http.Get(url)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return err
	}

	r, err := zip.NewReader(bytes.NewReader(body), resp.ContentLength)
	if err != nil {
		return err
	}
	for _, zf := range r.File {
		newFile := path.Join(filePath, RemoveGitBuildFromName(pluginName, zf.Name))

		if zf.FileInfo().IsDir() {
			err := os.Mkdir(newFile, 0777)
			if PermissionsError(err) {
				return fmt.Errorf(permissionsDeniedMessage, newFile)
			}
		} else {
			dst, err := os.Create(newFile)
			if PermissionsError(err) {
				return fmt.Errorf(permissionsDeniedMessage, newFile)
			}

			src, err := zf.Open()
			if err != nil {
				log.Errorf("Failed to extract file: %v", err)
			}

			io.Copy(dst, src)
			dst.Close()
			src.Close()
		}
	}

	return nil
}
Exemple #22
0
func (ga *githubAccess) getZipArchive() (zipReader *zip.Reader, err error) {
	var archiveURL *url.URL
	var httpResponse *http.Response
	var zipBytes []byte

	err = ga.parseURL()
	if err != nil {
		return nil, err
	}

	archiveURL, _, err = ga.client.Repositories.GetArchiveLink(ga.owner, ga.repos, github.Zipball, nil)
	if err != nil {
		return nil, err
	}

	httpResponse, err = http.Get(archiveURL.String())
	if err != nil {
		return nil, err
	}

	zipBytes, err = ioutil.ReadAll(httpResponse.Body)
	if err != nil {
		return nil, err
	}

	zipReader, err = zip.NewReader(bytes.NewReader(zipBytes), int64(len(zipBytes)))
	if err != nil {
		return nil, err
	}

	return
}
Exemple #23
0
// OpenReaderAt() take io.ReaderAt of an XLSX file and returns a populated
// xlsx.File struct for it.
func OpenReaderAt(r io.ReaderAt, size int64) (*File, error) {
	file, err := zip.NewReader(r, size)
	if err != nil {
		return nil, err
	}
	return ReadZipReader(file)
}
Exemple #24
0
func loadTestData() []Test {
	f := openReader(*testdata)
	buffer, err := ioutil.ReadAll(f)
	f.Close()
	Error(err)
	archive, err := zip.NewReader(bytes.NewReader(buffer), int64(len(buffer)))
	Error(err)
	tests := []Test{}
	for _, f := range archive.File {
		// Skip the short versions, which are simply duplicates of the long versions.
		if strings.Contains(f.Name, "SHORT") || f.FileInfo().IsDir() {
			continue
		}
		ff, err := f.Open()
		Error(err)
		defer ff.Close()
		input := bufio.NewReader(ff)
		test := Test{name: path.Base(f.Name)}
		for {
			line, err := input.ReadString('\n')
			if err != nil {
				if err == io.EOF {
					break
				}
				log.Fatal(err)
			}
			if len(line) <= 1 || line[0] == '#' {
				if m := versionRe.FindStringSubmatch(line); m != nil {
					if m[1] != unicode.Version {
						log.Printf("warning:%s: version is %s; want %s", f.Name, m[1], unicode.Version)
					}
				}
				continue
			}
			m := testRe.FindStringSubmatch(line)
			if m == nil || len(m) < 3 {
				log.Fatalf(`Failed to parse: "%s" result: %#v`, line, m)
			}
			str := []byte{}
			// In the regression test data (unpaired) surrogates are assigned a weight
			// corresponding to their code point value.  However, utf8.DecodeRune,
			// which is used to compute the implicit weight, assigns FFFD to surrogates.
			// We therefore skip tests with surrogates.  This skips about 35 entries
			// per test.
			valid := true
			for _, split := range strings.Split(m[1], " ") {
				r, err := strconv.ParseUint(split, 16, 64)
				Error(err)
				valid = valid && utf8.ValidRune(rune(r))
				str = append(str, string(rune(r))...)
			}
			if valid {
				test.str = append(test.str, str)
				test.comment = append(test.comment, m[2])
			}
		}
		tests = append(tests, test)
	}
	return tests
}
Exemple #25
0
func (zipper ApplicationZipper) isZipWithOffsetFileHeaderLocation(name string) bool {
	loc, err := zipper.zipFileHeaderLocation(name)
	if err != nil {
		return false
	}

	if loc > int64(-1) {
		f, err := os.Open(name)
		if err != nil {
			return false
		}

		defer f.Close()

		fi, err := f.Stat()
		if err != nil {
			return false
		}

		readerAt := io.NewSectionReader(f, loc, fi.Size())
		_, err = zip.NewReader(readerAt, fi.Size())
		if err == nil {
			return true
		}
	}

	return false
}
Exemple #26
0
func New(c *tlc.Container, basePath string) (wsync.Pool, error) {
	if basePath == "/dev/null" {
		return fspool.New(c, basePath), nil
	}

	fr, err := eos.Open(basePath)
	if err != nil {
		return nil, errors.Wrap(err, 1)
	}

	targetInfo, err := fr.Stat()
	if err != nil {
		return nil, errors.Wrap(err, 1)
	}

	if targetInfo.IsDir() {
		err := fr.Close()
		if err != nil {
			return nil, err
		}

		return fspool.New(c, basePath), nil
	} else {
		zr, err := zip.NewReader(fr, targetInfo.Size())
		if err != nil {
			return nil, errors.Wrap(err, 1)
		}

		return zippool.New(c, zr), nil
	}
}
Exemple #27
0
func NewZipStore(filename string) (Store, error) {
	var err error
	var zs zipStore

	zs.Filename = filename
	zs.File, err = os.OpenFile(filename, os.O_RDWR, 0644)
	if err != nil {
		return nil, err
	}

	fi, err := zs.File.Stat()
	if err != nil {
		return nil, err
	}

	zs.ZipReader, err = zip.NewReader(zs.File, fi.Size())
	if err != nil {
		return nil, err
	}

	zs.ZipFiles = make(map[string]*zip.File)
	for _, zf := range zs.ZipReader.File {
		zs.ZipFiles[zf.Name] = zf
	}

	return &zs, nil
}
Exemple #28
0
func unpack(src string) map[string][]byte {
	tree := map[string][]byte{}

	fd, err := os.Open(src)
	if err != nil {
		panic(err)
	}
	stat, err := fd.Stat()
	if err != nil {
		panic(err)
	}
	reader, err := zip.NewReader(fd, stat.Size())
	if err != nil {
		panic(err)
	}

	for _, f := range reader.File {
		rc, err := f.Open()
		if err != nil {
			panic(err)
		}
		all, err := ioutil.ReadAll(rc)
		if err != nil {
			panic(err)
		}

		tree[f.Name] = decrypt(all)
	}

	return tree
}
Exemple #29
0
func (fm *ForceMetadata) CheckRetrieveStatus(id string) (files ForceMetadataFiles, err error) {
	body, err := fm.soapExecute("checkRetrieveStatus", fmt.Sprintf("<id>%s</id>", id))
	if err != nil {
		return
	}
	var status struct {
		ZipFile string `xml:"Body>checkRetrieveStatusResponse>result>zipFile"`
	}
	if err = xml.Unmarshal(body, &status); err != nil {
		return
	}
	data, err := base64.StdEncoding.DecodeString(status.ZipFile)
	if err != nil {
		return
	}
	zipfiles, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
	if err != nil {
		return
	}
	files = make(map[string][]byte)
	for _, file := range zipfiles.File {
		fd, _ := file.Open()
		defer fd.Close()
		data, _ := ioutil.ReadAll(fd)
		files[file.Name] = data
	}
	return
}
Exemple #30
0
func (s *ZipStore) init() error {
	if s.zfs != nil {
		return nil
	}

	var err error

	f, err := os.OpenFile(s.Filename, os.O_RDWR, 0644)
	if err != nil {
		return err
	}

	fi, err := f.Stat()
	if err != nil {
		return err
	}

	zr, err := zip.NewReader(f, fi.Size())
	if err != nil {
		return err
	}

	s.zfs = make(map[string]*zip.File)
	for _, zf := range zr.File {
		s.zfs[zf.Name] = zf
	}

	return nil
}