unpacker_stub.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : unpacker stub program                                             *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2006-$now By Author.  This program 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 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "common_bundle.h"

#include <basis/array.cpp>
#include <basis/byte_array.h>
#include <basis/guards.h>
#include <basis/portable.h>
#include <data_struct/string_table.h>
#include <opsystem/application_shell.h>
#include <opsystem/byte_filer.h>
#include <opsystem/command_line.h>
#include <loggers/console_logger.h>
#include <opsystem/directory.h>
#include <opsystem/filename.h>
#include <loggers/file_logger.h>
#include <opsystem/filetime.h>
#include <opsystem/heavy_file_ops.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/parser_bits.h>
#include <textual/tokenizer.h>
#include <win_ext/window_classist.h>

#include <stdio.h>
#include <sys/stat.h>
#include <zlib.h>
#ifdef __UNIX__
  #include <utime.h>
#endif
#ifdef __WIN32__
  #include <direct.h>
  #include <io.h>
  #include <shlobj.h>
  #include <sys/utime.h>
#endif

const int CHUNKING_SIZE = 64 * KILOBYTE;
  // we'll read this big a chunk from a source file at a time.

#define BASE_LOG(to_print) program_wide_logger().log(to_print)
#define LOG(to_print) STAMPED_EMERGENCY_LOG(program_wide_logger(), to_print)

//#define DEBUG_STUB
  // uncomment for noisier version.

const char *ERROR_TITLE = "An Error Caused Incomplete Installation";
  // used in error messages as the title.


class unpacker_stub : public application_shell
{
public:
  unpacker_stub()
    : application_shell("unpacker_stub"),
      _app_name(filename(__argv[0]).basename()) {}
  IMPLEMENT_CLASS_NAME("unpacker_stub");

  int print_instructions();

  virtual int execute();

private:
  istring _app_name;
  array<manifest_chunk> _manifest;  
  string_table _variables;  
};


void show_message(const istring &msg, const istring &title)
{
#ifndef __WIN32__
  BASE_LOG(title);
  BASE_LOG(istring('-', title.length()));
  BASE_LOG(msg);
#else
  MessageBox(0, to_unicode_temp(msg), to_unicode_temp(title),
      MB_OK | MB_ICONINFORMATION);
#endif
}

int unpacker_stub::print_instructions()
{
  isprintf msg("\
    %s: This program unpacks its contents into the locations\n\
 specified at packing time.  The --target flag can be used to specify a\n\
different TARGET directory for the installation (for components that use\n\
the default TARGET variable to specify their install folder).\n\
    One can also pass a --keyword flag to specify a keyword; the files in the\n\
bundle that are marked with that keyword will be installed, but files that\n\
are missing the keyword will not be.\n\
    Further, variables can be overridden on the command line in the\n\
form: X=Y.\n\n\
The line below uses all these parameters as an example:\n\n\
  %s --target c:\\Program Files\\gubernator --keyword dlls_only SILENT=true\n\
\n\
Additional Notes:\n\
\n\
    One helpful variable is \"LOGDIR\".  This is where the unpacking log file\n\
will be written to.  The default is \"~/logs\" (or \"$TMP/logs\" on win32)\n\
until overridden.\n\
\n", _app_name.s(), _app_name.s());
  show_message(msg, "Unpacking Instructions");
  return 12;
}

// the string embedded into the array is not mentioned anywhere else in this
// program, which should allow the packer to find it and fix the manifest
// size.  the keyword is: "muftiloc", and the first bytes that can be
// overwritten are its beginning offset plus its length of 8 chars.  there
// is room for 8 bytes after the tag, but currently the first 4 are used as
// a 32 bit offset.
byte MANIFEST_OFFSET_ARRAY[]
    = { 'm', 'u', 'f', 't', 'i', 'l', 'o', 'c', 0, 0, 0, 0, 0, 0, 0, 0 };

int unpacker_stub::execute()
{
#ifdef ADMIN_CHECK
  #ifdef __WIN32__
    if (IsUserAnAdmin()) {
      ::MessageBox(0, to_unicode_temp("IS admin in bundler"), to_unicode_temp("bundler"), MB_OK);
    } else {
      ::MessageBox(0, to_unicode_temp("NOT admin in bundler"), to_unicode_temp("bundler"), MB_OK);
    }
  #endif
#endif

  command_line cmds(__argc, __argv);

  int indy = 0;
  if (cmds.find('?', indy)) return print_instructions();
  if (cmds.find("?", indy)) return print_instructions();

  // make sure we provide the same services as the bundle creator for the
  // default set of variables.
#ifndef __WIN32__
  portable::set_environ("EXE_END", "");  // executable file ending.
  portable::set_environ("DLL_START", "lib");  // dll file prefix.
  portable::set_environ("DLL_END", ".so");  // dll file ending.
#else
  portable::set_environ("EXE_END", ".exe");
  portable::set_environ("DLL_START", "");
  portable::set_environ("DLL_END", ".dll");
#endif

  // set TARGET directory if passed on the command line,
  bool provided_target = true;  // true if the command line specified target.
  istring target;
  cmds.get_value("target", target);
  // a bogus default is provided if they don't specify the destination.
  if (!target) {
    target = portable::env_string("TMP") + "/unbundled";
    provided_target = false;
  }
//LOG(istring("target is now ") + target);
  portable::set_environ("TARGET", target);

  {
    istring logdir = portable::env_string("LOGDIR");
#ifdef __WIN32__
    if (!logdir) {
      logdir = portable::env_string("TMP") + "/logs";
      portable::set_environ("LOGDIR", logdir);
    }
#else
    if (!logdir) {
      istring homedir = portable::env_string("HOME");
      logdir = homedir + "/logs";
      portable::set_environ("LOGDIR", logdir);
    }
#endif
  }

  istring keyword;  // set if we were given a keyword on cmd line.
  cmds.get_value("keyword", keyword);

  istring vars_set;  // we will document the variables we saw and show later.

  for (int x = 0; x < cmds.entries(); x++) {
    command_parameter curr = cmds.get(x);
    if (curr.type() != command_parameter::VALUE) continue;  // skip it.
    if (curr.text().find('=', 0) < 0) continue;  // no equals character.
    tokenizer t;
    t.parse(curr.text());
    if (!t.symbols()) continue;  // didn't parse right.
    istring var = t.table().name(0);
    istring value = t.table()[0];
    vars_set += istring("variable set: ") + var + "=" + value
        + log_base::platform_ending();
    _variables.add(var, value);
    portable::set_environ(var, value);
  }

  // get the most up to date version of the variable now.
  istring logdir = portable::env_string("LOGDIR");

  istring appname = filename(portable::application_name()).rootname();
  istring logname = logdir + "/" + appname + ".log";
  log_base *old_log = set_PW_logger_for_combo(logname);
  WHACK(old_log);

  BASE_LOG(istring('#', 76));
  BASE_LOG(appname + " command-line parameters:");
  BASE_LOG(cmds.text_form());
  BASE_LOG(istring('#', 76));

  BASE_LOG(vars_set);

#ifdef __WIN32__
  // create a window so that installshield won't barf.  this is only needed
  // on windows when using this as a prerequisite for installshield.
  window_handle f_window = create_simplistic_window("temp_stubby_class",
      "stubby window title");
#endif

  // read position for manifest offset out of our array.
  byte_array temp_packed(2 * sizeof(int), MANIFEST_OFFSET_ARRAY + 8);
  int manifest_offset;
  if (!basis::obscure_detach(temp_packed, manifest_offset)) {
    show_message(istring("could not read manifest offset in: ") + __argv[0],
        ERROR_TITLE);
    return 24;
  }
  
  filename this_exe(__argv[0]);
  if (!this_exe.exists()) {
    show_message(istring("could not access this exe image: ") + this_exe.raw(),
        ERROR_TITLE);
    return 23;
  }

  // start reading the manifest...
  byte_filer our_exe(this_exe, "rb");
  our_exe.seek(manifest_offset);  // go to where the manifest starts.

  // get number of chunks in manifest as the first bytes.
  if (our_exe.read(temp_packed, 2 * sizeof(int)) <= 0) {
    show_message(istring("could not read the manifest length in: ")
        + this_exe.raw(), ERROR_TITLE);
    return 26;
  }
  int item_count;
  basis::obscure_detach(temp_packed, item_count);
//check result of detach!
  _manifest.insert(0, item_count);  // add enough spaces for our item list.

  // read each item definition out of the manifest now.
  for (int i = 0; i < item_count; i++) {
    manifest_chunk &curr = _manifest[i];
    bool worked = manifest_chunk::read_manifest(our_exe, curr);
    if (!worked) {
      show_message(isprintf("could not read chunk for item #%d [%s]: ", i,
          curr._target.s())
          + this_exe.raw(), ERROR_TITLE);
      return 86;
    }
  }

#ifdef DEBUG_STUB
  LOG("read the following info from manifest:");
  istring temp = "size\ttarget\r\n";
  for (int i = 0; i < _manifest.length(); i++) {
    manifest_chunk &curr = _manifest[i];
    temp += isprintf("%d\t%s\r\n", curr._size, curr._target.s());
  }
  guards::alert_message(temp, "manifest contents");
#endif

  // now we should be just after the last byte of the manifest, at the
  // first piece of data.  we should read each chunk of data out and store
  // it where it's supposed to go.
  for (int festdex = 0; festdex < _manifest.length(); festdex++) {
    manifest_chunk &curr = _manifest[festdex];
    int size_left = curr._size;

    // patch in our environment variables.
    curr._target = parser_bits::substitute_env_vars(curr._target, false);
    curr._parms = parser_bits::substitute_env_vars(curr._parms, false);
#ifdef DEBUG_STUB
    BASE_LOG(istring("processing ") + curr._target
        + isprintf(", size=%d, flags=%d", curr._size, curr._flags));
    if (!!curr._parms)
      BASE_LOG(istring("   parms: ") + curr._parms);
#endif

    // see if they specified a keyword on the command line.
    bool keyword_good = true;
    if (!!keyword && !curr._keywords.member(keyword)) {
      // their keyword choice didn't match what we were pickled with.
      keyword_good = false;
//BASE_LOG(istring("skipping ") + curr._target + " for wrong keyword " + keyword);
    }

    if (curr._flags & SET_VARIABLE) {
      if (keyword_good) {
        // this is utterly different from a real target.  we just set a
        // variable and move on.
        if (provided_target && (curr._target == "TARGET") ) {
          BASE_LOG(istring("skipping ") + curr._target + "=" + curr._parms
              + ": was provided explicitly as " + target);
        } else if (_variables.find(curr._target)) {
          BASE_LOG(istring("skipping ") + curr._target + "=" + curr._parms
              + ": was provided on command line.");
        } else {
          BASE_LOG(istring("setting ") + curr._target + "=" + curr._parms);
          portable::set_environ(curr._target, curr._parms);

          // special code for changing logging directory midstream.
          if (curr._target == "LOGDIR") {
            istring logdir = curr._parms;
            istring appname = filename(portable::application_name()).rootname();
            istring logname = logdir + "/" + appname + ".log";
            log_base *old_log = set_PW_logger_for_combo(logname);
            WHACK(old_log);
          }
        }
      }
      continue;
    }

    if (! (curr._flags & OMIT_PACKING) ) {
      // this one has a payload, so install it now.

      // make sure that the directories needed are present for the outputs.
      filename target_dir = filename(curr._target).dirname();
      if (keyword_good && !target_dir.exists()
          && !directory::recursive_create(target_dir)) {
        LOG(isprintf("failed to create directory %s for item #%d: ",
            target_dir.raw().s(), festdex) + curr._target);
      }

      if (curr._flags & NO_OVERWRITE) {
        filename target_file(curr._target);
        if (target_file.exists()) {
          BASE_LOG(istring("not overwriting existing ") + curr._target);
          keyword_good = false;
        }
      }

      byte_filer *targo = NIL;
      if (keyword_good) targo = new byte_filer(curr._target, "wb");
      byte_array uncompressed(256 * KILOBYTE);  // fluff it out to begin with.
      byte_array temp(256 * KILOBYTE);

      bool first_read = true;
        // true if there haven't been any reads of the file before now.
      bool too_tiny_complaint_already = false;
        // becomes true if we complain about the file's size being larger than
        // expected.  this allows us to only complain once about each file.

      // read a chunk at a time out of our exe image and store it into the
      // target file.
      while (first_read || !our_exe.eof()) {
        first_read = false;
        int real_size = 0, packed_size = 0;
        // read in the real size from the file.
        bool worked = manifest_chunk::read_an_obscured_int(our_exe, real_size);
        if (!worked) {
          show_message(isprintf("failed while reading real size "
              "for item #%d: ", festdex) + curr._target, ERROR_TITLE);
          return 99;
        }
        // read in the packed size now.
        worked = manifest_chunk::read_an_obscured_int(our_exe, packed_size);
        if (!worked) {
          show_message(isprintf("failed while reading packed size "
              "for item #%d: ", festdex) + curr._target, ERROR_TITLE);
          return 99;
        }

        // make sure we don't eat the whole package--did the file end?
        if ( (real_size == -1) && (packed_size == -1) ) {
          // we've hit our sentinel; we've already unpacked all of this file.
          break;
        }

#ifdef DEBUG_STUB
        BASE_LOG(isprintf("chunk packed_size=%d, real_size=%d", packed_size,
            real_size));
#endif

        // now we know how big our next chunk is, so we can try reading it.
        if (packed_size) {
          int ret = our_exe.read(temp, packed_size);
          if (ret <= 0) {
            show_message(isprintf("failed while reading item #%d: ", festdex)
                + curr._target, ERROR_TITLE);
            return 99;
          } else if (ret != packed_size) {
            show_message(isprintf("bad trouble ahead, item #%d had different "
                " size on read (expected %d, got %d): ", festdex, packed_size,
                ret) + curr._target, ERROR_TITLE);
          }

          uncompressed.reset(real_size + KILOBYTE);  // add some for paranoia.
          uLongf destlen = uncompressed.length();
          int uncomp_ret = uncompress(uncompressed.access(), &destlen,
              temp.observe(), packed_size);
          if (uncomp_ret != Z_OK) {
            show_message(isprintf("failed while uncompressing item #%d: ",
                festdex) + curr._target, ERROR_TITLE);
            return 99;
          }
  
          if (int(destlen) != real_size) {
            LOG(isprintf("got a different unpacked size for item #%d: ",
                festdex) + curr._target);
          }

          // update the remaining size for this data chunk.
          size_left -= real_size;
          if (size_left < 0) {
            if (!too_tiny_complaint_already) {
              LOG(isprintf("item #%d was larger than expected (non-fatal): ",
                  festdex) + curr._target);
              too_tiny_complaint_already = true;
            }
          }
          // toss the extra bytes out.
          uncompressed.zap(real_size, uncompressed.length() - 1);

          if (targo) {
            // stuff the data we read into the target file.
            ret = targo->write(uncompressed);
            if (ret != uncompressed.length()) {
              show_message(isprintf("failed while writing item #%d: ", festdex)
                  + curr._target, ERROR_TITLE);
              return 93;
            }
          }
        }
      }
      if (targo) targo->close();
      WHACK(targo);
      // the file's written, but now we slap it's old time on it too.
      file_time t;
      if (!t.unpack(curr._timestamp)) {
        show_message(istring("failed to interpret timestamp for ")
            + curr._target, ERROR_TITLE);
        return 97;
      }
      utimbuf held_time;
      held_time.actime = t.raw();
      held_time.modtime = t.raw();
      // put the timestamp on the file.
      utime(curr._target.s(), &held_time);
    }

    // now that we're pretty sure the file exists, we can run it if needed.
    if ( (curr._flags & TARGET_EXECUTE) && keyword_good) {    
      // change the mode on the target file so we can execute it.
      chmod(curr._target.s(), 0766);
      istring prev_dir = portable::current_directory();

      BASE_LOG(istring("launching ") + curr._target);
      if (!!curr._parms)
        BASE_LOG(istring("  with parameters: ") + curr._parms);
      BASE_LOG(istring('-', 76));

      u_int kid;
      u_int retval = portable::launch_process(curr._target, curr._parms,
          portable::AWAIT_APP_EXIT | portable::HIDE_APP_WINDOW, kid);
      if (retval != 0) {
        if (! (curr._flags & IGNORE_ERRORS) ) {
          if (curr._flags & QUIET_FAILURE) {
            // no message box for this, but still log it.
            LOG(istring("failed to launch process, targ=")
                + curr._target + " with parms " + curr._parms
                + isprintf(" error=%d", retval));
          } else {
            show_message(istring("failed to launch process, targ=")
                + curr._target + " with parms " + curr._parms
                + isprintf(" error=%d", retval), ERROR_TITLE);
          }
          return retval;  // pass along same exit value we were told.
        } else {
          LOG(istring("ignoring failure to launch process, targ=")
              + curr._target + " with parms " + curr._parms
              + isprintf(" error=%d", retval));
        }
      }

      chdir(prev_dir.s());  // reset directory pointer, just in case.

      BASE_LOG(istring('-', 76));
    }

  }

#ifdef __WIN32__
  whack_simplistic_window(f_window);
#endif

  return 0;
}


HOOPLE_MAIN(unpacker_stub, )

#ifdef __BUILD_STATIC_APPLICATION__
  // static dependencies found by buildor_gen_deps.sh:
  #include <basis/array.cpp>
  #include <basis/byte_array.cpp>
  #include <basis/callstack_tracker.cpp>
  #include <basis/chaos.cpp>
  #include <basis/convert_utf.cpp>
  #include <basis/definitions.cpp>
  #include <basis/earth_time.cpp>
  #include <basis/guards.cpp>
  #include <basis/istring.cpp>
  #include <basis/log_base.cpp>
  #include <basis/memory_checker.cpp>
  #include <basis/mutex.cpp>
  #include <basis/object_base.cpp>
  #include <basis/outcome.cpp>
  #include <basis/packable.cpp>
  #include <basis/portable.cpp>
  #include <basis/sequence.cpp>
  #include <basis/set.cpp>
  #include <basis/utility.cpp>
  #include <basis/version_record.cpp>
  #include <data_struct/amorph.cpp>
  #include <data_struct/bit_vector.cpp>
  #include <data_struct/byte_hasher.cpp>
  #include <data_struct/configurator.cpp>
  #include <data_struct/hash_table.cpp>
  #include <data_struct/pointer_hash.cpp>
  #include <data_struct/stack.cpp>
  #include <data_struct/static_memory_gremlin.cpp>
  #include <data_struct/string_hash.cpp>
  #include <data_struct/string_hasher.cpp>
  #include <data_struct/string_table.cpp>
  #include <data_struct/symbol_table.cpp>
  #include <data_struct/table_configurator.cpp>
  #include <loggers/console_logger.cpp>
  #include <loggers/file_logger.cpp>
  #include <loggers/locked_logger.cpp>
  #include <loggers/null_logger.cpp>
  #include <loggers/program_wide_logger.cpp>
  #include <opsystem/application_base.cpp>
  #include <opsystem/application_shell.cpp>
  #include <opsystem/byte_filer.cpp>
  #include <opsystem/command_line.cpp>
  #include <opsystem/critical_events.cpp>
  #include <opsystem/directory.cpp>
  #include <opsystem/file_info.cpp>
  #include <opsystem/filename.cpp>
  #include <opsystem/filename_list.cpp>
  #include <opsystem/filetime.cpp>
  #include <opsystem/heavy_file_ops.cpp>
  #include <opsystem/huge_file.cpp>
  #include <opsystem/ini_config.cpp>
  #include <opsystem/ini_parser.cpp>
  #include <opsystem/path_configuration.cpp>
  #include <opsystem/rendezvous.cpp>
  #include <textual/byte_format.cpp>
  #include <textual/parser_bits.cpp>
  #include <textual/string_manipulation.cpp>
  #include <textual/tokenizer.cpp>
#endif // __BUILD_STATIC_APPLICATION__

---