third_party/ijar/ijar.cc - bazel - Git at Google

 // Copyright 2015 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.
 //
 // ijar.cpp -- .jar -> _interface.jar tool.
 //

 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <memory>

 #include "third_party/ijar/zip.h"

 namespace devtools_ijar {

 bool verbose = false;

 // Reads a JVM class from classdata_in (of the specified length), and
 // writes out a simplified class to classdata_out, advancing the
 // pointer. Returns true if the class should be kept.
 bool StripClass(u1 *&classdata_out, const u1 *classdata_in, size_t in_length);

 const char *CLASS_EXTENSION = ".class";
 const size_t CLASS_EXTENSION_LENGTH = strlen(CLASS_EXTENSION);
 const char *KOTLIN_MODULE_EXTENSION = ".kotlin_module";
 const size_t KOTLIN_MODULE_EXTENSION_LENGTH = strlen(KOTLIN_MODULE_EXTENSION);

 const char *MANIFEST_DIR_PATH = "META-INF/";
 const size_t MANIFEST_DIR_PATH_LENGTH = strlen(MANIFEST_DIR_PATH);
 const char *MANIFEST_PATH = "META-INF/MANIFEST.MF";
 const size_t MANIFEST_PATH_LENGTH = strlen(MANIFEST_PATH);
 const char *MANIFEST_HEADER =
     "Manifest-Version: 1.0\r\n"
     "Created-By: bazel\r\n";
 const size_t MANIFEST_HEADER_LENGTH = strlen(MANIFEST_HEADER);
 // These attributes are used by JavaBuilder, Turbine, and ijar.
 // They must all be kept in sync.
 const char *TARGET_LABEL_KEY = "Target-Label: ";
 const size_t TARGET_LABEL_KEY_LENGTH = strlen(TARGET_LABEL_KEY);
 const char *INJECTING_RULE_KIND_KEY = "Injecting-Rule-Kind: ";
 const size_t INJECTING_RULE_KIND_KEY_LENGTH = strlen(INJECTING_RULE_KIND_KEY);

 class JarExtractorProcessor : public ZipExtractorProcessor {
  public:
   // Set the ZipBuilder to add the ijar class to the output zip file.
   // This pointer should not be deleted while this class is still in use and
   // it should be set before any call to the Process() method.
   void SetZipBuilder(ZipBuilder *builder) { this->builder_ = builder; }
   virtual void WriteManifest(const char *target_label,
                              const char *injecting_rule_kind) = 0;

  protected:
   // Not owned by JarStripperProcessor, see SetZipBuilder().
   ZipBuilder *builder_;
 };

 // ZipExtractorProcessor that select only .class file and use
 // StripClass to generate an interface class, storing as a new file
 // in the specified ZipBuilder.
 class JarStripperProcessor : public JarExtractorProcessor {
  public:
   JarStripperProcessor() {}
   virtual ~JarStripperProcessor() {}

   virtual void Process(const char *filename, const u4 attr, const u1 *data,
                        const size_t size);
   virtual bool Accept(const char *filename, const u4 attr);

   virtual void WriteManifest(const char *target_label,
                              const char *injecting_rule_kind);
 };

 static bool StartsWith(const char *str, const size_t str_len,
                        const char *prefix, const size_t prefix_len) {
   return str_len >= prefix_len && strncmp(str, prefix, prefix_len) == 0;
 }

 static bool EndsWith(const char *str, const size_t str_len, const char *suffix,
                      const size_t suffix_len) {
   return str_len >= suffix_len &&
          strcmp(str + str_len - suffix_len, suffix) == 0;
 }

 static bool IsKotlinModule(const char *filename, const size_t filename_len) {
   return StartsWith(filename, filename_len, MANIFEST_DIR_PATH,
                     MANIFEST_DIR_PATH_LENGTH) &&
          EndsWith(filename, filename_len, KOTLIN_MODULE_EXTENSION,
                   KOTLIN_MODULE_EXTENSION_LENGTH);
 }

 bool JarStripperProcessor::Accept(const char *filename, const u4 /*attr*/) {
   const size_t filename_len = strlen(filename);
   if (IsKotlinModule(filename, filename_len)) {
     return true;
   }
   if (filename_len < CLASS_EXTENSION_LENGTH ||
       strcmp(filename + filename_len - CLASS_EXTENSION_LENGTH,
              CLASS_EXTENSION) != 0) {
     return false;
   }
   return true;
 }

 static bool IsModuleInfo(const char *filename) {
   const char *slash = strrchr(filename, '/');
   if (slash == NULL) {
     slash = filename;
   } else {
     slash++;
   }
   return strcmp(slash, "module-info.class") == 0;
 }

 void JarStripperProcessor::Process(const char *filename, const u4 /*attr*/,
                                    const u1 *data, const size_t size) {
   if (verbose) {
     fprintf(stderr, "INFO: StripClass: %s\n", filename);
   }
   if (IsModuleInfo(filename) || IsKotlinModule(filename, strlen(filename))) {
     u1 *q = builder_->NewFile(filename, 0);
     memcpy(q, data, size);
     builder_->FinishFile(size, /* compress: */ false, /* compute_crc: */ true);
   } else {
     u1 *buf = reinterpret_cast<u1 *>(malloc(size));
     u1 *classdata_out = buf;
     if (!StripClass(buf, data, size)) {
       free(classdata_out);
       return;
     }
     u1 *q = builder_->NewFile(filename, 0);
     size_t out_length = buf - classdata_out;
     memcpy(q, classdata_out, out_length);
     builder_->FinishFile(out_length, /* compress: */ false,
                          /* compute_crc: */ true);
     free(classdata_out);
   }
 }

 // Copies the string into the buffer without the null terminator, returns
 // updated buffer pointer
 static u1 *WriteStr(u1 *buf, const char *str) {
   size_t len = strlen(str);
   memcpy(buf, str, len);
   return buf + len;
 }

 // Writes a manifest attribute including a "\r\n" line break, returns updated
 // buffer pointer.
 static u1 *WriteManifestAttr(u1 *buf, const char *key, const char *val) {
   buf = WriteStr(buf, key);
   buf = WriteStr(buf, val);
   *buf++ = '\r';
   *buf++ = '\n';
   return buf;
 }

 void JarStripperProcessor::WriteManifest(const char *target_label,
                                          const char *injecting_rule_kind) {
   if (target_label == nullptr) {
     return;
   }
   builder_->WriteEmptyFile(MANIFEST_DIR_PATH);
   u1 *start = builder_->NewFile(MANIFEST_PATH, 0);
   u1 *buf = start;
   buf = WriteStr(buf, MANIFEST_HEADER);
   buf = WriteManifestAttr(buf, TARGET_LABEL_KEY, target_label);
   if (injecting_rule_kind) {
     buf = WriteManifestAttr(buf, INJECTING_RULE_KIND_KEY, injecting_rule_kind);
   }
   size_t total_len = buf - start;
   builder_->FinishFile(total_len, /* compress: */ false,
                        /* compute_crc: */ true);
 }

 class JarCopierProcessor : public JarExtractorProcessor {
  public:
   JarCopierProcessor(const char *jar) : jar_(jar) {}
   virtual ~JarCopierProcessor() {}

   virtual void Process(const char *filename, const u4 /*attr*/, const u1 *data,
                        const size_t size);
   virtual bool Accept(const char *filename, const u4 /*attr*/);

   virtual void WriteManifest(const char *target_label,
                              const char *injecting_rule_kind);

  private:
   class ManifestLocator : public ZipExtractorProcessor {
    public:
     ManifestLocator() : manifest_buf_(nullptr), manifest_size_(0) {}
     virtual ~ManifestLocator() { free(manifest_buf_); }

     u1 *manifest_buf_;
     size_t manifest_size_;

     virtual bool Accept(const char *filename, const u4 /*attr*/) {
       return strcmp(filename, MANIFEST_PATH) == 0;
     }

     virtual void Process(const char * /*filename*/, const u4 /*attr*/,
                          const u1 *data, const size_t size) {
       manifest_buf_ = (u1 *)malloc(size);
       memmove(manifest_buf_, data, size);
       manifest_size_ = size;
     }
   };

   const char *jar_;

   u1 *AppendTargetLabelToManifest(u1 *buf, const u1 *manifest_data,
                                   const size_t size, const char *target_label,
                                   const char *injecting_rule_kind);
 };

 void JarCopierProcessor::Process(const char *filename, const u4 /*attr*/,
                                  const u1 *data, const size_t size) {
   if (verbose) {
     fprintf(stderr, "INFO: CopyFile: %s\n", filename);
   }
   // We already handled the manifest in WriteManifest
   if (strcmp(filename, MANIFEST_DIR_PATH) == 0 ||
       strcmp(filename, MANIFEST_PATH) == 0) {
     return;
   }
   u1 *q = builder_->NewFile(filename, 0);
   memcpy(q, data, size);
   builder_->FinishFile(size, /* compress: */ false, /* compute_crc: */ true);
 }

 bool JarCopierProcessor::Accept(const char * /*filename*/, const u4 /*attr*/) {
   return true;
 }

 void JarCopierProcessor::WriteManifest(const char *target_label,
                                        const char *injecting_rule_kind) {
   ManifestLocator manifest_locator;
   std::unique_ptr<ZipExtractor> in(
       ZipExtractor::Create(jar_, &manifest_locator));
   in->ProcessAll();

   bool wants_manifest =
       manifest_locator.manifest_buf_ != nullptr || target_label != nullptr;
   if (wants_manifest) {
     builder_->WriteEmptyFile(MANIFEST_DIR_PATH);
     u1 *start = builder_->NewFile(MANIFEST_PATH, 0);
     u1 *buf = start;
     // Three cases:
     // 1. We need to merge the target label into a pre-existing manifest
     // 2. Write a manifest from scratch with a target label
     // 3. Copy existing manifest without adding target label
     if (manifest_locator.manifest_buf_ != nullptr && target_label != nullptr) {
       buf = AppendTargetLabelToManifest(buf, manifest_locator.manifest_buf_,
                                         manifest_locator.manifest_size_,
                                         target_label, injecting_rule_kind);
     } else if (target_label != nullptr) {
       buf = WriteStr(buf, MANIFEST_HEADER);
       buf = WriteManifestAttr(buf, TARGET_LABEL_KEY, target_label);
       if (injecting_rule_kind) {
         buf = WriteManifestAttr(buf, INJECTING_RULE_KIND_KEY,
                                 injecting_rule_kind);
       }
     } else {
       memcpy(buf, manifest_locator.manifest_buf_,
              manifest_locator.manifest_size_);
       buf += manifest_locator.manifest_size_;
     }

     size_t total_len = buf - start;
     builder_->FinishFile(total_len, /* compress: */ false,
                          /* compute_crc: */ true);
   }
 }

 u1 *JarCopierProcessor::AppendTargetLabelToManifest(
     u1 *buf, const u1 *manifest_data, const size_t size,
     const char *target_label, const char *injecting_rule_kind) {
   const char *line_start = (const char *)manifest_data;
   const char *data_end = (const char *)manifest_data + size;
   while (line_start < data_end) {
     const char *line_end = strchr(line_start, '\n');
     // Go past return char to point to next line, or to end of data buffer
     line_end = line_end != nullptr ? line_end + 1 : data_end;

     // Copy line unless it's Target-Label/Injecting-Rule-Kind and we're writing
     // that ourselves
     if (strncmp(line_start, TARGET_LABEL_KEY, TARGET_LABEL_KEY_LENGTH) != 0 &&
         strncmp(line_start, INJECTING_RULE_KIND_KEY,
                 INJECTING_RULE_KIND_KEY_LENGTH) != 0) {
       size_t len = line_end - line_start;
       // Skip empty lines
       if (len > 0 && line_start[0] != '\r' && line_start[0] != '\n') {
         memcpy(buf, line_start, len);
         buf += len;
       }
     }
     line_start = line_end;
   }
   buf = WriteManifestAttr(buf, TARGET_LABEL_KEY, target_label);
   if (injecting_rule_kind != nullptr) {
     buf = WriteManifestAttr(buf, INJECTING_RULE_KIND_KEY, injecting_rule_kind);
   }
   return buf;
 }

 // WriteManifest, including zip file format overhead.
 static size_t EstimateManifestOutputSize(const char *target_label,
                                          const char *injecting_rule_kind) {
   if (target_label == nullptr) {
     return 0;
   }
   // local headers
   size_t length = 30 * 2 + MANIFEST_DIR_PATH_LENGTH + MANIFEST_PATH_LENGTH;
   // central directory
   length += 46 * 2 + MANIFEST_DIR_PATH_LENGTH + MANIFEST_PATH_LENGTH;
   // zip64 EOCD entries
   length += 56 * 2;

   // manifest content
   length += MANIFEST_HEADER_LENGTH;
   // target label manifest entry, including newline
   length += TARGET_LABEL_KEY_LENGTH + strlen(target_label) + 2;
   if (injecting_rule_kind) {
     // injecting rule kind manifest entry, including newline
     length += INJECTING_RULE_KIND_KEY_LENGTH + strlen(injecting_rule_kind) + 2;
   }
   return length;
 }

 // Opens "file_in" (a .jar file) for reading, and writes an interface
 // .jar to "file_out".
 static void OpenFilesAndProcessJar(const char *file_out, const char *file_in,
                                    bool strip_jar, const char *target_label,
                                    const char *injecting_rule_kind) {
   std::unique_ptr<JarExtractorProcessor> processor;
   if (strip_jar) {
     processor =
         std::unique_ptr<JarExtractorProcessor>(new JarStripperProcessor());
   } else {
     processor =
         std::unique_ptr<JarExtractorProcessor>(new JarCopierProcessor(file_in));
   }
   std::unique_ptr<ZipExtractor> in(
       ZipExtractor::Create(file_in, processor.get()));
   if (in == NULL) {
     fprintf(stderr, "Unable to open Zip file %s: %s\n", file_in,
             strerror(errno));
     abort();
   }
   u8 output_length =
       in->CalculateOutputLength() +
       EstimateManifestOutputSize(target_label, injecting_rule_kind);
   std::unique_ptr<ZipBuilder> out(ZipBuilder::Create(file_out, output_length));
   if (out == NULL) {
     fprintf(stderr, "Unable to open output file %s: %s\n", file_out,
             strerror(errno));
     abort();
   }
   processor->SetZipBuilder(out.get());
   processor->WriteManifest(target_label, injecting_rule_kind);

   // Process all files in the zip
   if (in->ProcessAll() < 0) {
     fprintf(stderr, "%s\n", in->GetError());
     abort();
   }

   // Add dummy file, since javac doesn't like truly empty jars.
   if (out->GetNumberFiles() == 0) {
     out->WriteEmptyFile("dummy");
   }
   // Finish writing the output file
   if (out->Finish() < 0) {
     fprintf(stderr, "%s\n", out->GetError());
     abort();
   }
   // Get all file size
   size_t in_length = in->GetSize();
   size_t out_length = out->GetSize();
   if (verbose) {
     fprintf(stderr, "INFO: produced interface jar: %s -> %s (%d%%).\n", file_in,
             file_out, static_cast<int>(100.0 * out_length / in_length));
   }
 }
 }  // namespace devtools_ijar

 //
 // main method
 //
 static void usage() {
   fprintf(stderr,
           "Usage: ijar "
           "[-v] [--[no]strip_jar] "
           "[--target label label] [--injecting_rule_kind kind] "
           "x.jar [x_interface.jar>]\n");
   fprintf(stderr, "Creates an interface jar from the specified jar file.\n");
   exit(1);
 }

 int main(int argc, char **argv) {
   bool strip_jar = true;
   const char *target_label = NULL;
   const char *injecting_rule_kind = NULL;
   const char *filename_in = NULL;
   const char *filename_out = NULL;

   for (int ii = 1; ii < argc; ++ii) {
     if (strcmp(argv[ii], "-v") == 0) {
       devtools_ijar::verbose = true;
     } else if (strcmp(argv[ii], "--strip_jar") == 0) {
       strip_jar = true;
     } else if (strcmp(argv[ii], "--nostrip_jar") == 0) {
       strip_jar = false;
     } else if (strcmp(argv[ii], "--target_label") == 0) {
       if (++ii >= argc) {
         usage();
       }
       target_label = argv[ii];
     } else if (strcmp(argv[ii], "--injecting_rule_kind") == 0) {
       if (++ii >= argc) {
         usage();
       }
       injecting_rule_kind = argv[ii];
     } else if (filename_in == NULL) {
       filename_in = argv[ii];
     } else if (filename_out == NULL) {
       filename_out = argv[ii];
     } else {
       usage();
     }
   }

   if (filename_in == NULL) {
     usage();
   }

   // Guess output filename from input:
   char filename_out_buf[PATH_MAX];
   if (filename_out == NULL) {
     size_t len = strlen(filename_in);
     if (len > 4 && strncmp(filename_in + len - 4, ".jar", 4) == 0) {
       strcpy(filename_out_buf, filename_in);
       strcpy(filename_out_buf + len - 4, "-interface.jar");
       filename_out = filename_out_buf;
     } else {
       fprintf(stderr,
               "Can't determine output filename since input filename "
               "doesn't end with '.jar'.\n");
       return 1;
     }
   }

   if (devtools_ijar::verbose) {
     fprintf(stderr, "INFO: writing to '%s'.\n", filename_out);
   }

   devtools_ijar::OpenFilesAndProcessJar(filename_out, filename_in, strip_jar,
                                         target_label, injecting_rule_kind);
   return 0;
 }
	// Copyright 2015 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.
	//
	// ijar.cpp -- .jar -> _interface.jar tool.
	//

	#include <errno.h>
	#include <limits.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <memory>

	#include "third_party/ijar/zip.h"

	namespace devtools_ijar {

	bool verbose = false;

	// Reads a JVM class from classdata_in (of the specified length), and
	// writes out a simplified class to classdata_out, advancing the
	// pointer. Returns true if the class should be kept.
	bool StripClass(u1 &classdata_out, const u1 classdata_in, size_t in_length);

	const char *CLASS_EXTENSION = ".class";
	const size_t CLASS_EXTENSION_LENGTH = strlen(CLASS_EXTENSION);
	const char *KOTLIN_MODULE_EXTENSION = ".kotlin_module";
	const size_t KOTLIN_MODULE_EXTENSION_LENGTH = strlen(KOTLIN_MODULE_EXTENSION);

	const char *MANIFEST_DIR_PATH = "META-INF/";
	const size_t MANIFEST_DIR_PATH_LENGTH = strlen(MANIFEST_DIR_PATH);
	const char *MANIFEST_PATH = "META-INF/MANIFEST.MF";
	const size_t MANIFEST_PATH_LENGTH = strlen(MANIFEST_PATH);
	const char *MANIFEST_HEADER =
	"Manifest-Version: 1.0\r\n"
	"Created-By: bazel\r\n";
	const size_t MANIFEST_HEADER_LENGTH = strlen(MANIFEST_HEADER);
	// These attributes are used by JavaBuilder, Turbine, and ijar.
	// They must all be kept in sync.
	const char *TARGET_LABEL_KEY = "Target-Label: ";
	const size_t TARGET_LABEL_KEY_LENGTH = strlen(TARGET_LABEL_KEY);
	const char *INJECTING_RULE_KIND_KEY = "Injecting-Rule-Kind: ";
	const size_t INJECTING_RULE_KIND_KEY_LENGTH = strlen(INJECTING_RULE_KIND_KEY);

	class JarExtractorProcessor : public ZipExtractorProcessor {
	public:
	// Set the ZipBuilder to add the ijar class to the output zip file.
	// This pointer should not be deleted while this class is still in use and
	// it should be set before any call to the Process() method.
	void SetZipBuilder(ZipBuilder *builder) { this->builder_ = builder; }
	virtual void WriteManifest(const char *target_label,
	const char *injecting_rule_kind) = 0;

	protected:
	// Not owned by JarStripperProcessor, see SetZipBuilder().
	ZipBuilder *builder_;
	};

	// ZipExtractorProcessor that select only .class file and use
	// StripClass to generate an interface class, storing as a new file
	// in the specified ZipBuilder.
	class JarStripperProcessor : public JarExtractorProcessor {
	public:
	JarStripperProcessor() {}
	virtual ~JarStripperProcessor() {}

	virtual void Process(const char filename, const u4 attr, const u1 data,
	const size_t size);
	virtual bool Accept(const char *filename, const u4 attr);

	virtual void WriteManifest(const char *target_label,
	const char *injecting_rule_kind);
	};

	static bool StartsWith(const char *str, const size_t str_len,
	const char *prefix, const size_t prefix_len) {
	return str_len >= prefix_len && strncmp(str, prefix, prefix_len) == 0;
	}

	static bool EndsWith(const char str, const size_t str_len, const char suffix,
	const size_t suffix_len) {
	return str_len >= suffix_len &&
	strcmp(str + str_len - suffix_len, suffix) == 0;
	}

	static bool IsKotlinModule(const char *filename, const size_t filename_len) {
	return StartsWith(filename, filename_len, MANIFEST_DIR_PATH,
	MANIFEST_DIR_PATH_LENGTH) &&
	EndsWith(filename, filename_len, KOTLIN_MODULE_EXTENSION,
	KOTLIN_MODULE_EXTENSION_LENGTH);
	}

	bool JarStripperProcessor::Accept(const char filename, const u4 /attr*/) {
	const size_t filename_len = strlen(filename);
	if (IsKotlinModule(filename, filename_len)) {
	return true;
	}
	if (filename_len < CLASS_EXTENSION_LENGTH \|\|
	strcmp(filename + filename_len - CLASS_EXTENSION_LENGTH,
	CLASS_EXTENSION) != 0) {
	return false;
	}
	return true;
	}

	static bool IsModuleInfo(const char *filename) {
	const char *slash = strrchr(filename, '/');
	if (slash == NULL) {
	slash = filename;
	} else {
	slash++;
	}
	return strcmp(slash, "module-info.class") == 0;
	}

	void JarStripperProcessor::Process(const char filename, const u4 /attr*/,
	const u1 *data, const size_t size) {
	if (verbose) {
	fprintf(stderr, "INFO: StripClass: %s\n", filename);
	}
	if (IsModuleInfo(filename) \|\| IsKotlinModule(filename, strlen(filename))) {
	u1 *q = builder_->NewFile(filename, 0);
	memcpy(q, data, size);
	builder_->FinishFile(size, /* compress: / false, / compute_crc: */ true);
	} else {
	u1 buf = reinterpret_cast<u1 >(malloc(size));
	u1 *classdata_out = buf;
	if (!StripClass(buf, data, size)) {
	free(classdata_out);
	return;
	}
	u1 *q = builder_->NewFile(filename, 0);
	size_t out_length = buf - classdata_out;
	memcpy(q, classdata_out, out_length);
	builder_->FinishFile(out_length, /* compress: */ false,
	/* compute_crc: */ true);
	free(classdata_out);
	}
	}

	// Copies the string into the buffer without the null terminator, returns
	// updated buffer pointer
	static u1 WriteStr(u1 buf, const char *str) {
	size_t len = strlen(str);
	memcpy(buf, str, len);
	return buf + len;
	}

	// Writes a manifest attribute including a "\r\n" line break, returns updated
	// buffer pointer.
	static u1 WriteManifestAttr(u1 buf, const char key, const char val) {
	buf = WriteStr(buf, key);
	buf = WriteStr(buf, val);
	*buf++ = '\r';
	*buf++ = '\n';
	return buf;
	}

	void JarStripperProcessor::WriteManifest(const char *target_label,
	const char *injecting_rule_kind) {
	if (target_label == nullptr) {
	return;
	}
	builder_->WriteEmptyFile(MANIFEST_DIR_PATH);
	u1 *start = builder_->NewFile(MANIFEST_PATH, 0);
	u1 *buf = start;
	buf = WriteStr(buf, MANIFEST_HEADER);
	buf = WriteManifestAttr(buf, TARGET_LABEL_KEY, target_label);
	if (injecting_rule_kind) {
	buf = WriteManifestAttr(buf, INJECTING_RULE_KIND_KEY, injecting_rule_kind);
	}
	size_t total_len = buf - start;
	builder_->FinishFile(total_len, /* compress: */ false,
	/* compute_crc: */ true);
	}

	class JarCopierProcessor : public JarExtractorProcessor {
	public:
	JarCopierProcessor(const char *jar) : jar_(jar) {}
	virtual ~JarCopierProcessor() {}

	virtual void Process(const char filename, const u4 /attr/, const u1 data,
	const size_t size);
	virtual bool Accept(const char filename, const u4 /attr*/);

	virtual void WriteManifest(const char *target_label,
	const char *injecting_rule_kind);

	private:
	class ManifestLocator : public ZipExtractorProcessor {
	public:
	ManifestLocator() : manifest_buf_(nullptr), manifest_size_(0) {}
	virtual ~ManifestLocator() { free(manifest_buf_); }

	u1 *manifest_buf_;
	size_t manifest_size_;

	virtual bool Accept(const char filename, const u4 /attr*/) {
	return strcmp(filename, MANIFEST_PATH) == 0;
	}

	virtual void Process(const char * /filename/, const u4 /attr/,
	const u1 *data, const size_t size) {
	manifest_buf_ = (u1 *)malloc(size);
	memmove(manifest_buf_, data, size);
	manifest_size_ = size;
	}
	};

	const char *jar_;

	u1 AppendTargetLabelToManifest(u1 buf, const u1 *manifest_data,
	const size_t size, const char *target_label,
	const char *injecting_rule_kind);
	};

	void JarCopierProcessor::Process(const char filename, const u4 /attr*/,
	const u1 *data, const size_t size) {
	if (verbose) {
	fprintf(stderr, "INFO: CopyFile: %s\n", filename);
	}
	// We already handled the manifest in WriteManifest
	if (strcmp(filename, MANIFEST_DIR_PATH) == 0 \|\|
	strcmp(filename, MANIFEST_PATH) == 0) {
	return;
	}
	u1 *q = builder_->NewFile(filename, 0);
	memcpy(q, data, size);
	builder_->FinishFile(size, /* compress: / false, / compute_crc: */ true);
	}

	bool JarCopierProcessor::Accept(const char * /filename/, const u4 /attr/) {
	return true;
	}

	void JarCopierProcessor::WriteManifest(const char *target_label,
	const char *injecting_rule_kind) {
	ManifestLocator manifest_locator;
	std::unique_ptr<ZipExtractor> in(
	ZipExtractor::Create(jar_, &manifest_locator));
	in->ProcessAll();

	bool wants_manifest =
	manifest_locator.manifest_buf_ != nullptr \|\| target_label != nullptr;
	if (wants_manifest) {
	builder_->WriteEmptyFile(MANIFEST_DIR_PATH);
	u1 *start = builder_->NewFile(MANIFEST_PATH, 0);
	u1 *buf = start;
	// Three cases:
	// 1. We need to merge the target label into a pre-existing manifest
	// 2. Write a manifest from scratch with a target label
	// 3. Copy existing manifest without adding target label
	if (manifest_locator.manifest_buf_ != nullptr && target_label != nullptr) {
	buf = AppendTargetLabelToManifest(buf, manifest_locator.manifest_buf_,
	manifest_locator.manifest_size_,
	target_label, injecting_rule_kind);
	} else if (target_label != nullptr) {
	buf = WriteStr(buf, MANIFEST_HEADER);
	buf = WriteManifestAttr(buf, TARGET_LABEL_KEY, target_label);
	if (injecting_rule_kind) {
	buf = WriteManifestAttr(buf, INJECTING_RULE_KIND_KEY,
	injecting_rule_kind);
	}
	} else {
	memcpy(buf, manifest_locator.manifest_buf_,
	manifest_locator.manifest_size_);
	buf += manifest_locator.manifest_size_;
	}

	size_t total_len = buf - start;
	builder_->FinishFile(total_len, /* compress: */ false,
	/* compute_crc: */ true);
	}
	}

	u1 *JarCopierProcessor::AppendTargetLabelToManifest(
	u1 buf, const u1 manifest_data, const size_t size,
	const char target_label, const char injecting_rule_kind) {
	const char line_start = (const char )manifest_data;
	const char data_end = (const char )manifest_data + size;
	while (line_start < data_end) {
	const char *line_end = strchr(line_start, '\n');
	// Go past return char to point to next line, or to end of data buffer
	line_end = line_end != nullptr ? line_end + 1 : data_end;

	// Copy line unless it's Target-Label/Injecting-Rule-Kind and we're writing
	// that ourselves
	if (strncmp(line_start, TARGET_LABEL_KEY, TARGET_LABEL_KEY_LENGTH) != 0 &&
	strncmp(line_start, INJECTING_RULE_KIND_KEY,
	INJECTING_RULE_KIND_KEY_LENGTH) != 0) {
	size_t len = line_end - line_start;
	// Skip empty lines
	if (len > 0 && line_start[0] != '\r' && line_start[0] != '\n') {
	memcpy(buf, line_start, len);
	buf += len;
	}
	}
	line_start = line_end;
	}
	buf = WriteManifestAttr(buf, TARGET_LABEL_KEY, target_label);
	if (injecting_rule_kind != nullptr) {
	buf = WriteManifestAttr(buf, INJECTING_RULE_KIND_KEY, injecting_rule_kind);
	}
	return buf;
	}

	// WriteManifest, including zip file format overhead.
	static size_t EstimateManifestOutputSize(const char *target_label,
	const char *injecting_rule_kind) {
	if (target_label == nullptr) {
	return 0;
	}
	// local headers
	size_t length = 30 * 2 + MANIFEST_DIR_PATH_LENGTH + MANIFEST_PATH_LENGTH;
	// central directory
	length += 46 * 2 + MANIFEST_DIR_PATH_LENGTH + MANIFEST_PATH_LENGTH;
	// zip64 EOCD entries
	length += 56 * 2;

	// manifest content
	length += MANIFEST_HEADER_LENGTH;
	// target label manifest entry, including newline
	length += TARGET_LABEL_KEY_LENGTH + strlen(target_label) + 2;
	if (injecting_rule_kind) {
	// injecting rule kind manifest entry, including newline
	length += INJECTING_RULE_KIND_KEY_LENGTH + strlen(injecting_rule_kind) + 2;
	}
	return length;
	}

	// Opens "file_in" (a .jar file) for reading, and writes an interface
	// .jar to "file_out".
	static void OpenFilesAndProcessJar(const char file_out, const char file_in,
	bool strip_jar, const char *target_label,
	const char *injecting_rule_kind) {
	std::unique_ptr<JarExtractorProcessor> processor;
	if (strip_jar) {
	processor =
	std::unique_ptr<JarExtractorProcessor>(new JarStripperProcessor());
	} else {
	processor =
	std::unique_ptr<JarExtractorProcessor>(new JarCopierProcessor(file_in));
	}
	std::unique_ptr<ZipExtractor> in(
	ZipExtractor::Create(file_in, processor.get()));
	if (in == NULL) {
	fprintf(stderr, "Unable to open Zip file %s: %s\n", file_in,
	strerror(errno));
	abort();
	}
	u8 output_length =
	in->CalculateOutputLength() +
	EstimateManifestOutputSize(target_label, injecting_rule_kind);
	std::unique_ptr<ZipBuilder> out(ZipBuilder::Create(file_out, output_length));
	if (out == NULL) {
	fprintf(stderr, "Unable to open output file %s: %s\n", file_out,
	strerror(errno));
	abort();
	}
	processor->SetZipBuilder(out.get());
	processor->WriteManifest(target_label, injecting_rule_kind);

	// Process all files in the zip
	if (in->ProcessAll() < 0) {
	fprintf(stderr, "%s\n", in->GetError());
	abort();
	}

	// Add dummy file, since javac doesn't like truly empty jars.
	if (out->GetNumberFiles() == 0) {
	out->WriteEmptyFile("dummy");
	}
	// Finish writing the output file
	if (out->Finish() < 0) {
	fprintf(stderr, "%s\n", out->GetError());
	abort();
	}
	// Get all file size
	size_t in_length = in->GetSize();
	size_t out_length = out->GetSize();
	if (verbose) {
	fprintf(stderr, "INFO: produced interface jar: %s -> %s (%d%%).\n", file_in,
	file_out, static_cast<int>(100.0 * out_length / in_length));
	}
	}
	} // namespace devtools_ijar

	//
	// main method
	//
	static void usage() {
	fprintf(stderr,
	"Usage: ijar "
	"[-v] [--[no]strip_jar] "
	"[--target label label] [--injecting_rule_kind kind] "
	"x.jar [x_interface.jar>]\n");
	fprintf(stderr, "Creates an interface jar from the specified jar file.\n");
	exit(1);
	}

	int main(int argc, char **argv) {
	bool strip_jar = true;
	const char *target_label = NULL;
	const char *injecting_rule_kind = NULL;
	const char *filename_in = NULL;
	const char *filename_out = NULL;

	for (int ii = 1; ii < argc; ++ii) {
	if (strcmp(argv[ii], "-v") == 0) {
	devtools_ijar::verbose = true;
	} else if (strcmp(argv[ii], "--strip_jar") == 0) {
	strip_jar = true;
	} else if (strcmp(argv[ii], "--nostrip_jar") == 0) {
	strip_jar = false;
	} else if (strcmp(argv[ii], "--target_label") == 0) {
	if (++ii >= argc) {
	usage();
	}
	target_label = argv[ii];
	} else if (strcmp(argv[ii], "--injecting_rule_kind") == 0) {
	if (++ii >= argc) {
	usage();
	}
	injecting_rule_kind = argv[ii];
	} else if (filename_in == NULL) {
	filename_in = argv[ii];
	} else if (filename_out == NULL) {
	filename_out = argv[ii];
	} else {
	usage();
	}
	}

	if (filename_in == NULL) {
	usage();
	}

	// Guess output filename from input:
	char filename_out_buf[PATH_MAX];
	if (filename_out == NULL) {
	size_t len = strlen(filename_in);
	if (len > 4 && strncmp(filename_in + len - 4, ".jar", 4) == 0) {
	strcpy(filename_out_buf, filename_in);
	strcpy(filename_out_buf + len - 4, "-interface.jar");
	filename_out = filename_out_buf;
	} else {
	fprintf(stderr,
	"Can't determine output filename since input filename "
	"doesn't end with '.jar'.\n");
	return 1;
	}
	}

	if (devtools_ijar::verbose) {
	fprintf(stderr, "INFO: writing to '%s'.\n", filename_out);
	}

	devtools_ijar::OpenFilesAndProcessJar(filename_out, filename_in, strip_jar,
	target_label, injecting_rule_kind);
	return 0;
	}