/* JarUtils.java -- Utility methods for reading/writing Manifest[-like] files
   Copyright (C) 2006, 2007 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package gnu.java.util.jar;

import gnu.classpath.SystemProperties;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.Map;
import java.util.jar.Attributes;
import java.util.jar.JarException;
import java.util.jar.Attributes.Name;
import java.util.logging.Logger;

/**
 * Utility methods for reading and writing JAR <i>Manifest</i> and
 * <i>Manifest-like</i> files.
 * <p>
 * JAR-related files that resemble <i>Manifest</i> files are Signature files
 * (with an <code>.SF</code> extension) found in signed JARs.
 */
public abstract class JarUtils
{
  // We used to log here, but this causes problems during bootstrap,
  // and it didn't seem worthwhile to preserve this.  Still, this
  // might be useful for debugging.
  // private static final Logger log = Logger.getLogger(JarUtils.class.getName());
  public static final String META_INF = "META-INF/";
  public static final String DSA_SUFFIX = ".DSA";
  public static final String SF_SUFFIX = ".SF";
  public static final String NAME = "Name";

  /**
   * The original string representation of the manifest version attribute name.
   */
  public static final String MANIFEST_VERSION = "Manifest-Version";

  /**
   * The original string representation of the signature version attribute
   * name.
   */
  public static final String SIGNATURE_VERSION = "Signature-Version";

  /** Platform-independent line-ending. */
  public static final byte[] CRLF = new byte[] { 0x0D, 0x0A };
  private static final String DEFAULT_MF_VERSION = "1.0";
  private static final String DEFAULT_SF_VERSION = "1.0";
  private static final Name CREATED_BY = new Name("Created-By");
  private static final String CREATOR = SystemProperties.getProperty("java.version")
                                        + " ("
                                        + SystemProperties.getProperty("java.vendor")
                                        + ")";

  // default 0-arguments constructor

  // Methods for reading Manifest files from InputStream ----------------------

  public static void
  readMFManifest(Attributes attr, Map entries, InputStream in)
      throws IOException
  {
    BufferedReader br = new BufferedReader(new InputStreamReader(in, "UTF-8"));
    readMainSection(attr, br);
    readIndividualSections(entries, br);
  }

  public static void
  readSFManifest(Attributes attr, Map entries, InputStream in)
      throws IOException
  {
    BufferedReader br = new BufferedReader(new InputStreamReader(in, "UTF-8"));
    String version_header = Name.SIGNATURE_VERSION.toString();
    try
      {
        String version = expectHeader(version_header, br);
        attr.putValue(SIGNATURE_VERSION, version);
        // This may cause problems during VM bootstrap.
        // if (! DEFAULT_SF_VERSION.equals(version))
        //  log.warning("Unexpected version number: " + version
        //              + ". Continue (but may fail later)");
      }
    catch (IOException ioe)
      {
        throw new JarException("Signature file MUST start with a "
                               + version_header + ": " + ioe.getMessage());
      }
    read_attributes(attr, br);

    // read individual sections
    String s = br.readLine();
    while (s != null && s.length() > 0)
      {
        Attributes eAttr = readSectionName(s, br, entries);
        read_attributes(eAttr, br);
        s = br.readLine();
      }
  }

  private static void readMainSection(Attributes attr, BufferedReader br)
      throws IOException
  {
    // According to the spec we should actually call read_version_info() here.
    read_attributes(attr, br);
    // Explicitly set Manifest-Version attribute if not set in Main
    // attributes of Manifest.
    // XXX (rsn): why 0.0 and not 1.0?
    if (attr.getValue(Name.MANIFEST_VERSION) == null)
      attr.putValue(MANIFEST_VERSION, "0.0");
  }

  private static void readIndividualSections(Map entries, BufferedReader br)
      throws IOException
  {
    String s = br.readLine();
    while (s != null && (! s.equals("")))
      {
        Attributes attr = readSectionName(s, br, entries);
        read_attributes(attr, br);
        s = br.readLine();
      }
  }

  /**
   * Pedantic method that requires the next attribute in the Manifest to be the
   * "Manifest-Version". This follows the Manifest spec closely but reject some
   * jar Manifest files out in the wild.
   */
  private static void readVersionInfo(Attributes attr, BufferedReader br)
      throws IOException
  {
    String version_header = Name.MANIFEST_VERSION.toString();
    try
      {
        String value = expectHeader(version_header, br);
        attr.putValue(MANIFEST_VERSION, value);
      }
    catch (IOException ioe)
      {
        throw new JarException("Manifest should start with a " + version_header
                               + ": " + ioe.getMessage());
      }
  }

  private static String expectHeader(String header, BufferedReader br)
      throws IOException
  {
    String s = br.readLine();
    if (s == null)
      throw new JarException("unexpected end of file");

    return expectHeader(header, br, s);
  }

  private static void read_attributes(Attributes attr, BufferedReader br)
      throws IOException
  {
    String s = br.readLine();
    while (s != null && (! s.equals("")))
      {
        readAttribute(attr, s, br);
        s = br.readLine();
      }
  }

  private static void
  readAttribute(Attributes attr, String s, BufferedReader br) throws IOException
  {
    try
      {
        int colon = s.indexOf(": ");
        String name = s.substring(0, colon);
        String value_start = s.substring(colon + 2);
        String value = readHeaderValue(value_start, br);
        attr.putValue(name, value);
      }
    catch (IndexOutOfBoundsException iobe)
      {
        throw new JarException("Manifest contains a bad header: " + s);
      }
  }

  private static String readHeaderValue(String s, BufferedReader br)
      throws IOException
  {
    boolean try_next = true;
    while (try_next)
      {
        // Lets see if there is something on the next line
        br.mark(1);
        if (br.read() == ' ')
          s += br.readLine();
        else
          {
            br.reset();
            try_next = false;
          }
      }
    return s;
  }

  private static Attributes
  readSectionName(String s, BufferedReader br, Map entries) throws JarException
  {
    try
      {
        String name = expectHeader(NAME, br, s);
        Attributes attr = new Attributes();
        entries.put(name, attr);
        return attr;
      }
    catch (IOException ioe)
      {
        throw new JarException("Section should start with a Name header: "
                               + ioe.getMessage());
      }
  }

  private static String expectHeader(String header, BufferedReader br, String s)
      throws IOException
  {
    try
      {
        String name = s.substring(0, header.length() + 1);
        if (name.equalsIgnoreCase(header + ":"))
          {
            String value_start = s.substring(header.length() + 2);
            return readHeaderValue(value_start, br);
          }
      }
    catch (IndexOutOfBoundsException ignored)
      {
      }
    // If we arrive here, something went wrong
    throw new JarException("unexpected '" + s + "'");
  }

  // Methods for writing Manifest files to an OutputStream --------------------

  public static void
  writeMFManifest(Attributes attr, Map entries, OutputStream stream)
      throws IOException
  {
    BufferedOutputStream out = stream instanceof BufferedOutputStream
                               ? (BufferedOutputStream) stream
                               : new BufferedOutputStream(stream, 4096);
    writeVersionInfo(attr, out);
    Iterator i;
    Map.Entry e;
    for (i = attr.entrySet().iterator(); i.hasNext();)
      {
        e = (Map.Entry) i.next();
        // Don't print the manifest version again
        if (! Name.MANIFEST_VERSION.equals(e.getKey()))
          writeAttributeEntry(e, out);
      }
    out.write(CRLF);

    Iterator j;
    for (i = entries.entrySet().iterator(); i.hasNext();)
      {
        e = (Map.Entry) i.next();
        writeHeader(NAME, e.getKey().toString(), out);
        Attributes eAttr = (Attributes) e.getValue();
        for (j = eAttr.entrySet().iterator(); j.hasNext();)
          {
            Map.Entry e2 = (Map.Entry) j.next();
            writeAttributeEntry(e2, out);
          }
        out.write(CRLF);
      }

    out.flush();
  }

  public static void
  writeSFManifest(Attributes attr, Map entries, OutputStream stream)
      throws IOException
  {
    BufferedOutputStream out = stream instanceof BufferedOutputStream
                               ? (BufferedOutputStream) stream
                               : new BufferedOutputStream(stream, 4096);
    writeHeader(Name.SIGNATURE_VERSION.toString(), DEFAULT_SF_VERSION, out);
    writeHeader(CREATED_BY.toString(), CREATOR, out);
    Iterator i;
    Map.Entry e;
    for (i = attr.entrySet().iterator(); i.hasNext();)
      {
        e = (Map.Entry) i.next();
        Name name = (Name) e.getKey();
        if (Name.SIGNATURE_VERSION.equals(name) || CREATED_BY.equals(name))
          continue;

        writeHeader(name.toString(), (String) e.getValue(), out);
      }
    out.write(CRLF);

    Iterator j;
    for (i = entries.entrySet().iterator(); i.hasNext();)
      {
        e = (Map.Entry) i.next();
        writeHeader(NAME, e.getKey().toString(), out);
        Attributes eAttr = (Attributes) e.getValue();
        for (j = eAttr.entrySet().iterator(); j.hasNext();)
          {
            Map.Entry e2 = (Map.Entry) j.next();
            writeHeader(e2.getKey().toString(), (String) e2.getValue(), out);
          }
        out.write(CRLF);
      }

    out.flush();
  }

  private static void writeVersionInfo(Attributes attr, OutputStream out)
      throws IOException
  {
    // First check if there is already a version attribute set
    String version = attr.getValue(Name.MANIFEST_VERSION);
    if (version == null)
      version = DEFAULT_MF_VERSION;

    writeHeader(Name.MANIFEST_VERSION.toString(), version, out);
  }

  private static void writeAttributeEntry(Map.Entry entry, OutputStream out)
      throws IOException
  {
    String name = entry.getKey().toString();
    String value = entry.getValue().toString();
    if (name.equalsIgnoreCase(NAME))
      throw new JarException("Attributes cannot be called 'Name'");

    if (name.startsWith("From"))
      throw new JarException("Header cannot start with the four letters 'From'"
                             + name);

    writeHeader(name, value, out);
  }

  /**
   * The basic method for writing <code>Mainfest</code> attributes. This
   * implementation respects the rule stated in the Jar Specification concerning
   * the maximum allowed line length; i.e.
   *
   * <pre>
   * No line may be longer than 72 bytes (not characters), in its UTF8-encoded
   * form. If a value would make the initial line longer than this, it should
   * be continued on extra lines (each starting with a single SPACE).
   * </pre>
   *
   * and
   *
   * <pre>
   * Because header names cannot be continued, the maximum length of a header
   * name is 70 bytes (there must be a colon and a SPACE after the name).
   * </pre>
   *
   * @param name the name of the attribute.
   * @param value the value of the attribute.
   * @param out the output stream to write the attribute's name/value pair to.
   * @throws IOException if an I/O related exception occurs during the process.
   */
  private static void writeHeader(String name, String value, OutputStream out)
      throws IOException
  {
    String target = name + ": ";
    byte[] b = target.getBytes("UTF-8");
    if (b.length > 72)
      throw new IOException("Attribute's name already longer than 70 bytes");

    if (b.length == 72)
      {
        out.write(b);
        out.write(CRLF);
        target = " " + value;
      }
    else
      target = target + value;

    int n;
    while (true)
      {
        b = target.getBytes("UTF-8");
        if (b.length < 73)
          {
            out.write(b);
            break;
          }

        // find an appropriate character position to break on
        n = 72;
        while (true)
          {
            b = target.substring(0, n).getBytes("UTF-8");
            if (b.length < 73)
              break;

            n--;
            if (n < 1)
              throw new IOException("Header is unbreakable and longer than 72 bytes");
          }

        out.write(b);
        out.write(CRLF);
        target = " " + target.substring(n);
      }

    out.write(CRLF);
  }
}