src/tools/ak/repack/repack.go

// Copyright 2018 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Package repack provides functionality to repack zip/jar/apk archives.
package repack

import (
	"archive/zip"
	"flag"
	"io"
	"log"
	"os"
	"path/filepath"
	"strings"
	"sync"

	"src/common/golang/flags"
	"src/tools/ak/types"
)

var (
	// Cmd defines the command to run repack
	Cmd = types.Command{
		Init: Init,
		Run:  Run,
		Desc: desc,
		Flags: []string{
			"in",
			"dir",
			"out",
			"filtered_out",
			"filter_r",
			"filter_jar_res",
			"filter_manifest",
			"compress",
			"remove_dirs",
		},
	}

	// Variables that hold flag values
	in             flags.StringList
	dir            flags.StringList
	out            string
	filteredOut    string
	filterR        bool
	filterJarRes   bool
	filterManifest bool
	compress       bool
	removeDirs     bool

	b2i      = map[bool]int8{false: 0, true: 1}
	seen     = make(map[string]bool)
	initOnce sync.Once
)

// Init initializes repack.
func Init() {
	initOnce.Do(func() {
		flag.Var(&in, "in", "Path to input(s), must be a zip archive.")
		flag.Var(&dir, "dir", "Path to directories to pack in the zip.")
		flag.StringVar(&out, "out", "", "Path to output.")
		flag.StringVar(&filteredOut, "filtered_out", "", "(optional) Path to output for filtered files.")
		flag.BoolVar(&filterR, "filter_r", false, "Whether to filter R classes or not.")
		flag.BoolVar(&filterJarRes, "filter_jar_res", false, "Whether to filter java resources or not.")
		flag.BoolVar(&filterManifest, "filter_manifest", false, "Whether to filter AndroidManifest.xml or not.")
		flag.BoolVar(&compress, "compress", false, "Whether to compress or just store files in all outputs.")
		flag.BoolVar(&removeDirs, "remove_dirs", true, "Whether to remove directory entries or not.")
	})
}

func desc() string {
	return "Repack zip/jar/apk archives."
}

type filterFunc func(name string) bool

func filterNone(name string) bool {
	return false
}

func isRClass(name string) bool {
	return strings.HasSuffix(name, "/R.class") || strings.Contains(name, "/R$")
}

func isJavaRes(name string) bool {
	return !(strings.HasSuffix(name, ".class") || strings.HasPrefix(name, "META-INF/"))
}

func isManifest(name string) bool {
	return name == "AndroidManifest.xml"
}

func repackZip(in *zip.Reader, out *zip.Writer, filteredZipOut *zip.Writer, filter filterFunc, method uint16) error {
	for _, f := range in.File {
		if removeDirs && strings.HasSuffix(f.Name, "/") {
			continue
		}
		reader, err := f.Open()
		if err != nil {
			return err
		}
		if err := writeToZip(f.Name, reader, out, filteredZipOut, filter, method); err != nil {
			return err
		}
		if err := reader.Close(); err != nil {
			return err
		}
	}
	return nil
}

func repackDir(dir string, out *zip.Writer, filteredZipOut *zip.Writer, filter filterFunc, method uint16) error {
	return filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		name, err := filepath.Rel(dir, path)
		if info.IsDir() {
			if removeDirs {
				return nil
			}
			name += "/"
		}

		reader, err := os.Open(path)
		if err != nil {
			return err
		}
		defer reader.Close()

		return writeToZip(name, reader, out, filteredZipOut, filter, method)
	})
}

func writeToZip(name string, in io.Reader, out, filteredZipOut *zip.Writer, filter filterFunc, method uint16) error {
	if seen[name] {
		return nil
	}
	seen[name] = true

	if filter(name) {
		if filteredZipOut != nil {
			write(filteredZipOut, in, name, method)
		}
		return nil
	}
	return write(out, in, name, method)
}

func write(out *zip.Writer, in io.Reader, name string, method uint16) error {
	writer, err := out.CreateHeader(&zip.FileHeader{
		Name:   name,
		Method: method,
	})
	if err != nil {
		return err
	}

	// Only files have data, io.Copy will fail for directories. Header entry is required for both.
	if !strings.HasSuffix(name, "/") {
		if _, err := io.Copy(writer, in); err != nil {
			return err
		}
	}
	return nil
}

// Run is the entry point for repack.
func Run() {
	if in == nil && dir == nil {
		log.Fatal("Flags -in or -dir must be specified.")
	}
	if out == "" {
		log.Fatal("Flags -out must be specified.")
	}

	if b2i[filterR]+b2i[filterJarRes]+b2i[filterManifest] > 1 {
		log.Fatal("Only one filter is allowed.")
	}

	filter := filterNone
	if filterR {
		filter = isRClass
	} else if filterJarRes {
		filter = isJavaRes
	} else if filterManifest {
		filter = isManifest
	}

	w, err := os.Create(out)
	if err != nil {
		log.Fatalf("os.Create(%q) failed: %v", out, err)
	}
	defer w.Close()

	zipOut := zip.NewWriter(w)
	defer zipOut.Close()

	var filteredZipOut *zip.Writer
	if filteredOut != "" {
		w, err := os.Create(filteredOut)
		if err != nil {
			log.Fatalf("os.Create(%q) failed: %v", filteredOut, err)
		}
		defer w.Close()
		filteredZipOut = zip.NewWriter(w)
		defer filteredZipOut.Close()
	}

	method := zip.Store
	if compress {
		method = zip.Deflate
	}

	for _, d := range dir {
		if err := repackDir(d, zipOut, filteredZipOut, filter, method); err != nil {
			log.Fatal(err)
		}
	}

	for _, f := range in {
		file, err := os.Open(f)
		if err != nil {
			log.Fatalf("os.Open(%q) failed: %v", f, err)
		}
		fi, err := file.Stat()
		if err != nil {
			file.Close()
			log.Fatalf("File.Stat() failed for %q: %v", f, err)
		}
		size := fi.Size()
		// Skip empty Zip archives. An empty zip is 22 bytes contains only an EOCD.
		// https://en.wikipedia.org/wiki/Zip_(file_format)#Limits
		if size <= 22 {
			continue
		}
		zipIn, err := zip.NewReader(file, size)
		if err != nil {
			file.Close()
			log.Fatalf("zip.OpenReader(%q) failed: %v", f, err)
		}

		err = repackZip(zipIn, zipOut, filteredZipOut, filter, method)
		file.Close()
		if err != nil {
			log.Fatal(err)
		}
	}
}