/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

// -*- C++ -*-

// Program for unpacking specially compressed Java packages.

// John R. Rose

#include <sys/types.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <stdarg.h>

#include <limits.h>

#include <time.h>

#include "defines.h"

#include "bytes.h"

#include "utils.h"

#include "coding.h"

#include "bands.h"

#include "constants.h"

#include "zip.h"

#include "unpack.h"

// tags, in canonical order:

static const byte TAGS_IN_ORDER[] = {

  CONSTANT_Utf8,

  CONSTANT_Integer,

  CONSTANT_Float,

  CONSTANT_Long,

  CONSTANT_Double,

  CONSTANT_String,

  CONSTANT_Class,

  CONSTANT_Signature,

  CONSTANT_NameandType,

  CONSTANT_Fieldref,

  CONSTANT_Methodref,

  CONSTANT_InterfaceMethodref

};

#define N_TAGS_IN_ORDER (sizeof TAGS_IN_ORDER)

#ifndef PRODUCT

static const char* TAG_NAME[] = {

  "*None",

  "Utf8",

  "*Unicode",

  "Integer",

  "Float",

  "Long",

  "Double",

  "Class",

  "String",

  "Fieldref",

  "Methodref",

  "InterfaceMethodref",

  "NameandType",

  "*Signature",

  0

};

static const char* ATTR_CONTEXT_NAME[] = {  // match ATTR_CONTEXT_NAME, etc.

  "class", "field", "method", "code"

};

#else

#define ATTR_CONTEXT_NAME ((const char**)null)

#endif

// REQUESTED must be -2 for u2 and REQUESTED_LDC must be -1 for u1

enum { NOT_REQUESTED = 0, REQUESTED = -2, REQUESTED_LDC = -1 };

#define NO_INORD ((uint)-1)

struct entry {

  byte tag;

  #if 0

  byte bits;

  enum {

    //EB_EXTRA = 1,

    EB_SUPER = 2

  };

  #endif

  unsigned short nrefs;  // pack w/ tag

  int  outputIndex;

  uint inord;   // &cp.entries[cp.tag_base[this->tag]+this->inord] == this

  entry* *refs;

  // put last to pack best

  union {

    bytes b;

    int i;

    jlong l;

  } value;

  void requestOutputIndex(cpool& cp, int req = REQUESTED);

  int getOutputIndex() {

    assert(outputIndex > NOT_REQUESTED);

    return outputIndex;

  }

  entry* ref(int refnum) {

    assert((uint)refnum < nrefs);

    return refs[refnum];

  }

  const char* utf8String() {

    assert(tagMatches(CONSTANT_Utf8));

    assert(value.b.len == strlen((const char*)value.b.ptr));

    return (const char*)value.b.ptr;

  }

  entry* className() {

    assert(tagMatches(CONSTANT_Class));

    return ref(0);

  }

  entry* memberClass() {

    assert(tagMatches(CONSTANT_Member));

    return ref(0);

  }

  entry* memberDescr() {

    assert(tagMatches(CONSTANT_Member));

    return ref(1);

  }

  entry* descrName() {

    assert(tagMatches(CONSTANT_NameandType));

    return ref(0);

  }

  entry* descrType() {

    assert(tagMatches(CONSTANT_NameandType));

    return ref(1);

  }

  int typeSize();

  bytes& asUtf8();

  int    asInteger() { assert(tag == CONSTANT_Integer); return value.i; }

  bool isUtf8(bytes& b) { return tagMatches(CONSTANT_Utf8) && value.b.equals(b); }

  bool isDoubleWord() { return tag == CONSTANT_Double || tag == CONSTANT_Long; }

  bool tagMatches(byte tag2) {

    return (tag2 == tag)

      || (tag2 == CONSTANT_Utf8 && tag == CONSTANT_Signature)

      #ifndef PRODUCT

      || (tag2 == CONSTANT_Literal

          && tag >= CONSTANT_Integer && tag <= CONSTANT_String && tag != CONSTANT_Class)

      || (tag2 == CONSTANT_Member

          && tag >= CONSTANT_Fieldref && tag <= CONSTANT_InterfaceMethodref)

      #endif

      ;

  }

#ifdef PRODUCT

  char* string() { return 0; }

#else

  char* string();  // see far below

#endif

};

entry* cpindex::get(uint i) {

  if (i >= len)

    return null;

  else if (base1 != null)

    // primary index

    return &base1[i];

  else

    // secondary index

    return base2[i];

}

inline bytes& entry::asUtf8() {

  assert(tagMatches(CONSTANT_Utf8));

  return value.b;

}

int entry::typeSize() {

  assert(tagMatches(CONSTANT_Utf8));

  const char* sigp = (char*) value.b.ptr;

  switch (*sigp) {

  case '(': sigp++; break;  // skip opening '('

  case 'D':

  case 'J': return 2; // double field

  default:  return 1; // field

  }

  int siglen = 0;

  for (;;) {

    int ch = *sigp++;

    switch (ch) {

    case 'D': case 'J':

      siglen += 1;

      break;

    case '[':

      // Skip rest of array info.

      while (ch == '[') { ch = *sigp++; }

      if (ch != 'L')  break;

      // else fall through

    case 'L':

      sigp = strchr(sigp, ';');

      if (sigp == null) {

          unpack_abort("bad data");

          return 0;

      }

      sigp += 1;

      break;

    case ')':  // closing ')'

      return siglen;

    }

    siglen += 1;

  }

}

inline cpindex* cpool::getFieldIndex(entry* classRef) {

  assert(classRef->tagMatches(CONSTANT_Class));

  return &member_indexes[classRef->inord*2+0];

}

inline cpindex* cpool::getMethodIndex(entry* classRef) {

  assert(classRef->tagMatches(CONSTANT_Class));

  return &member_indexes[classRef->inord*2+1];

}

struct inner_class {

  entry* inner;

  entry* outer;

  entry* name;

  int    flags;

  inner_class* next_sibling;

  bool   requested;

};

// Here is where everything gets deallocated:

void unpacker::free() {

  int i;

  assert(jniobj == null); // caller resp.

  assert(infileptr == null);  // caller resp.

  if (jarout != null)  jarout->reset();

  if (gzin != null)    { gzin->free(); gzin = null; }

  if (free_input)  input.free();

  // free everybody ever allocated with U_NEW or (recently) with T_NEW

  assert(smallbuf.base()  == null || mallocs.contains(smallbuf.base()));

  assert(tsmallbuf.base() == null || tmallocs.contains(tsmallbuf.base()));

  mallocs.freeAll();

  tmallocs.freeAll();

  smallbuf.init();

  tsmallbuf.init();

  bcimap.free();

  class_fixup_type.free();

  class_fixup_offset.free();

  class_fixup_ref.free();

  code_fixup_type.free();

  code_fixup_offset.free();

  code_fixup_source.free();

  requested_ics.free();

  cur_classfile_head.free();

  cur_classfile_tail.free();

  for (i = 0; i < ATTR_CONTEXT_LIMIT; i++)

    attr_defs[i].free();

  // free CP state

  cp.outputEntries.free();

  for (i = 0; i < CONSTANT_Limit; i++)

    cp.tag_extras[i].free();

}

// input handling

// Attempts to advance rplimit so that (rplimit-rp) is at least 'more'.

// Will eagerly read ahead by larger chunks, if possible.

// Returns false if (rplimit-rp) is not at least 'more',

// unless rplimit hits input.limit().

bool unpacker::ensure_input(jlong more) {

  julong want = more - input_remaining();

  if ((jlong)want <= 0)          return true;  // it's already in the buffer

  if (rplimit == input.limit())  return true;  // not expecting any more

  if (read_input_fn == null) {

    // assume it is already all there

    bytes_read += input.limit() - rplimit;

    rplimit = input.limit();

    return true;

  }

  CHECK_0;

  julong remaining = (input.limit() - rplimit);  // how much left to read?

  byte* rpgoal = (want >= remaining)? input.limit(): rplimit + (size_t)want;

  enum { CHUNK_SIZE = (1<<14) };

  julong fetch = want;

  if (fetch < CHUNK_SIZE)

    fetch = CHUNK_SIZE;

  if (fetch > remaining*3/4)

    fetch = remaining;

  // Try to fetch at least "more" bytes.

  while ((jlong)fetch > 0) {

    jlong nr = (*read_input_fn)(this, rplimit, fetch, remaining);

    if (nr <= 0) {

      return (rplimit >= rpgoal);

    }

    remaining -= nr;

    rplimit += nr;

    fetch -= nr;

    bytes_read += nr;

  }

  return true;

}

// output handling

fillbytes* unpacker::close_output(fillbytes* which) {

  assert(wp != null);

  if (which == null) {

    if (wpbase == cur_classfile_head.base()) {

      which = &cur_classfile_head;

    } else {

      which = &cur_classfile_tail;

    }

  }

  assert(wpbase  == which->base());

  assert(wplimit == which->end());

  which->setLimit(wp);

  wp      = null;

  wplimit = null;

  //wpbase = null;

  return which;

}

//maybe_inline

void unpacker::ensure_put_space(size_t size) {

  if (wp + size <= wplimit)  return;

  // Determine which segment needs expanding.

  fillbytes* which = close_output();

  byte* wp0 = which->grow(size);

  wpbase  = which->base();

  wplimit = which->end();

  wp = wp0;

}

maybe_inline

byte* unpacker::put_space(size_t size) {

  byte* wp0 = wp;

  byte* wp1 = wp0 + size;

  if (wp1 > wplimit) {

    ensure_put_space(size);

    wp0 = wp;

    wp1 = wp0 + size;

  }

  wp = wp1;

  return wp0;

}

maybe_inline

void unpacker::putu2_at(byte* wp, int n) {

  if (n != (unsigned short)n) {

    unpack_abort(ERROR_OVERFLOW);

    return;

  }

  wp[0] = (n) >> 8;

  wp[1] = (n) >> 0;

}

maybe_inline

void unpacker::putu4_at(byte* wp, int n) {

  wp[0] = (n) >> 24;

  wp[1] = (n) >> 16;

  wp[2] = (n) >> 8;

  wp[3] = (n) >> 0;

}

maybe_inline

void unpacker::putu8_at(byte* wp, jlong n) {

  putu4_at(wp+0, (int)((julong)n >> 32));

  putu4_at(wp+4, (int)((julong)n >> 0));

}

maybe_inline

void unpacker::putu2(int n) {

  putu2_at(put_space(2), n);

}

maybe_inline

void unpacker::putu4(int n) {

  putu4_at(put_space(4), n);

}

maybe_inline

void unpacker::putu8(jlong n) {

  putu8_at(put_space(8), n);

}

maybe_inline

int unpacker::putref_index(entry* e, int size) {

  if (e == null)

    return 0;

  else if (e->outputIndex > NOT_REQUESTED)

    return e->outputIndex;

  else if (e->tag == CONSTANT_Signature)

    return putref_index(e->ref(0), size);

  else {

    e->requestOutputIndex(cp, -size);

    // Later on we'll fix the bits.

    class_fixup_type.addByte(size);

    class_fixup_ref.add(e);

  }

}

maybe_inline

void unpacker::putref(entry* e) {

  int oidx = putref_index(e, 2);

  putu2_at(put_space(2), oidx);

}

maybe_inline

void unpacker::putu1ref(entry* e) {

  int oidx = putref_index(e, 1);

  putu1_at(put_space(1), oidx);

}

static int total_cp_size[] = {0, 0};

static int largest_cp_ref[] = {0, 0};

static int hash_probes[] = {0, 0};

// Allocation of small and large blocks.

enum { CHUNK = (1 << 14), SMALL = (1 << 9) };

// Call malloc.  Try to combine small blocks and free much later.

void* unpacker::alloc_heap(size_t size, bool smallOK, bool temp) {

  CHECK_0;

  if (!smallOK || size > SMALL) {

    (temp ? &tmallocs : &mallocs)->add(res);

    return res;

  }

  fillbytes& xsmallbuf = *(temp ? &tsmallbuf : &smallbuf);

  if (!xsmallbuf.canAppend(size+1)) {

    xsmallbuf.init(CHUNK);

    (temp ? &tmallocs : &mallocs)->add(xsmallbuf.base());

  }

  growBy += -growBy & 7;  // round up mod 8

  return xsmallbuf.grow(growBy);

}

maybe_inline

void unpacker::saveTo(bytes& b, byte* ptr, size_t len) {

  b.ptr = U_NEW(byte, len+1);

  if (aborting()) {

    b.len = 0;

    return;

  }

  b.len = len;

  b.copyFrom(ptr, len);

}

// Read up through band_headers.

// Do the archive_size dance to set the size of the input mega-buffer.

void unpacker::read_file_header() {

  // Read file header to determine file type and total size.

  enum {

    MAGIC_BYTES = 4,

    AH_LENGTH_0 = 3,  //minver, majver, options are outside of archive_size