Linux v1.03 的 Java(tm) 二進位制核心支援

Linux 擊敗了所有！當所有其他作業系統都在談論在作業系統中直接支援 Java 二進位制檔案時，Linux 正在這樣做！

在完成以下操作後，您可以像執行任何其他程式一樣執行 Java 應用程式和 Java Applet

1. 您必須首先安裝 Linux 的 Java 開發工具包。 Linux 上的 Java HOWTO 提供了獲取和安裝的詳細資訊。 該 HOWTO 可以在以下位置找到

   ftp://sunsite.unc.edu/pub/Linux/docs/HOWTO/Java-HOWTO

   您還應該設定一個合理的 CLASSPATH 環境變數，以使用利用任何非標準類（未包含在與應用程式本身相同的目錄中）的 Java 應用程式。

2. 您必須將 BINFMT_MISC 編譯為模組或編譯到核心中 (CONFIG_BINFMT_MISC) 並正確設定它。 如果您選擇將其編譯為模組，您將必須使用 modprobe/insmod 手動插入它，因為 kmod 無法輕易支援 binfmt_misc。 閱讀此目錄中的檔案“binfmt_misc.txt”以瞭解有關配置過程的更多資訊。

3. 將以下配置項新增到 binfmt_misc（您現在應該真正閱讀了 binfmt_misc.txt）： 支援 Java 應用程式

   ':Java:M::\xca\xfe\xba\xbe::/usr/local/bin/javawrapper:'
   

   支援可執行 Jar 檔案

   ':ExecutableJAR:E::jar::/usr/local/bin/jarwrapper:'
   

   支援 Java Applets

   ':Applet:E::html::/usr/bin/appletviewer:'
   

   或者以下，如果您想更具選擇性

   ':Applet:M::<!--applet::/usr/bin/appletviewer:'
   

   當然，您必須修復路徑名。 本文件中給出的路徑/檔名與 Debian 2.1 系統匹配。（即，jdk 安裝在 /usr 中，來自本文件的自定義包裝器位於 /usr/local 中）

   請注意，為了獲得更具選擇性的 applet 支援，您必須修改現有的 html 檔案，使其第一行包含 <!--applet--> （< 必須是第一個字元！）才能使其正常工作！

   對於編譯後的 Java 程式，您需要一個像下面這樣的包裝指令碼（這是因為 Java 在檔名處理方面存在問題），再次修復指令碼和上面給出的配置字串中的路徑名。

   您也需要在指令碼之後的小程式。 像這樣編譯

   gcc -O2 -o javaclassname javaclassname.c
   

   並將其貼上到 /usr/local/bin。

   javawrapper shellscript 和 javaclassname 程式均由 Colin J. Watson <cjw44@cam.ac.uk> 提供。

Javawrapper shell 指令碼

#!/bin/bash
# /usr/local/bin/javawrapper - the wrapper for binfmt_misc/java

if [ -z "$1" ]; then
      exec 1>&2
      echo Usage: $0 class-file
      exit 1
fi

CLASS=$1
FQCLASS=`/usr/local/bin/javaclassname $1`
FQCLASSN=`echo $FQCLASS | sed -e 's/^.*\.\([^.]*\)$/\1/'`
FQCLASSP=`echo $FQCLASS | sed -e 's-\.-/-g' -e 's-^[^/]*$--' -e 's-/[^/]*$--'`

# for example:
# CLASS=Test.class
# FQCLASS=foo.bar.Test
# FQCLASSN=Test
# FQCLASSP=foo/bar

unset CLASSBASE

declare -i LINKLEVEL=0

while :; do
      if [ "`basename $CLASS .class`" == "$FQCLASSN" ]; then
              # See if this directory works straight off
              cd -L `dirname $CLASS`
              CLASSDIR=$PWD
              cd $OLDPWD
              if echo $CLASSDIR | grep -q "$FQCLASSP$"; then
                      CLASSBASE=`echo $CLASSDIR | sed -e "s.$FQCLASSP$.."`
                      break;
              fi
              # Try dereferencing the directory name
              cd -P `dirname $CLASS`
              CLASSDIR=$PWD
              cd $OLDPWD
              if echo $CLASSDIR | grep -q "$FQCLASSP$"; then
                      CLASSBASE=`echo $CLASSDIR | sed -e "s.$FQCLASSP$.."`
                      break;
              fi
              # If no other possible filename exists
              if [ ! -L $CLASS ]; then
                      exec 1>&2
                      echo $0:
                      echo "  $CLASS should be in a" \
                           "directory tree called $FQCLASSP"
                      exit 1
              fi
      fi
      if [ ! -L $CLASS ]; then break; fi
      # Go down one more level of symbolic links
      let LINKLEVEL+=1
      if [ $LINKLEVEL -gt 5 ]; then
              exec 1>&2
              echo $0:
              echo "  Too many symbolic links encountered"
              exit 1
      fi
      CLASS=`ls --color=no -l $CLASS | sed -e 's/^.* \([^ ]*\)$/\1/'`
done

if [ -z "$CLASSBASE" ]; then
      if [ -z "$FQCLASSP" ]; then
              GOODNAME=$FQCLASSN.class
      else
              GOODNAME=$FQCLASSP/$FQCLASSN.class
      fi
      exec 1>&2
      echo $0:
      echo "  $FQCLASS should be in a file called $GOODNAME"
      exit 1
fi

if ! echo $CLASSPATH | grep -q "^\(.*:\)*$CLASSBASE\(:.*\)*"; then
      # class is not in CLASSPATH, so prepend dir of class to CLASSPATH
      if [ -z "${CLASSPATH}" ] ; then
              export CLASSPATH=$CLASSBASE
      else
              export CLASSPATH=$CLASSBASE:$CLASSPATH
      fi
fi

shift
/usr/bin/java $FQCLASS "$@"

javaclassname.c

/* javaclassname.c
 *
 * Extracts the class name from a Java class file; intended for use in a Java
 * wrapper of the type supported by the binfmt_misc option in the Linux kernel.
 *
 * Copyright (C) 1999 Colin J. Watson <cjw44@cam.ac.uk>.
 *
 * 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 program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <sys/types.h>

/* From Sun's Java VM Specification, as tag entries in the constant pool. */

#define CP_UTF8 1
#define CP_INTEGER 3
#define CP_FLOAT 4
#define CP_LONG 5
#define CP_DOUBLE 6
#define CP_CLASS 7
#define CP_STRING 8
#define CP_FIELDREF 9
#define CP_METHODREF 10
#define CP_INTERFACEMETHODREF 11
#define CP_NAMEANDTYPE 12
#define CP_METHODHANDLE 15
#define CP_METHODTYPE 16
#define CP_INVOKEDYNAMIC 18

/* Define some commonly used error messages */

#define seek_error() error("%s: Cannot seek\n", program)
#define corrupt_error() error("%s: Class file corrupt\n", program)
#define eof_error() error("%s: Unexpected end of file\n", program)
#define utf8_error() error("%s: Only ASCII 1-255 supported\n", program);

char *program;

long *pool;

u_int8_t read_8(FILE *classfile);
u_int16_t read_16(FILE *classfile);
void skip_constant(FILE *classfile, u_int16_t *cur);
void error(const char *format, ...);
int main(int argc, char **argv);

/* Reads in an unsigned 8-bit integer. */
u_int8_t read_8(FILE *classfile)
{
      int b = fgetc(classfile);
      if(b == EOF)
              eof_error();
      return (u_int8_t)b;
}

/* Reads in an unsigned 16-bit integer. */
u_int16_t read_16(FILE *classfile)
{
      int b1, b2;
      b1 = fgetc(classfile);
      if(b1 == EOF)
              eof_error();
      b2 = fgetc(classfile);
      if(b2 == EOF)
              eof_error();
      return (u_int16_t)((b1 << 8) | b2);
}

/* Reads in a value from the constant pool. */
void skip_constant(FILE *classfile, u_int16_t *cur)
{
      u_int16_t len;
      int seekerr = 1;
      pool[*cur] = ftell(classfile);
      switch(read_8(classfile))
      {
      case CP_UTF8:
              len = read_16(classfile);
              seekerr = fseek(classfile, len, SEEK_CUR);
              break;
      case CP_CLASS:
      case CP_STRING:
      case CP_METHODTYPE:
              seekerr = fseek(classfile, 2, SEEK_CUR);
              break;
      case CP_METHODHANDLE:
              seekerr = fseek(classfile, 3, SEEK_CUR);
              break;
      case CP_INTEGER:
      case CP_FLOAT:
      case CP_FIELDREF:
      case CP_METHODREF:
      case CP_INTERFACEMETHODREF:
      case CP_NAMEANDTYPE:
      case CP_INVOKEDYNAMIC:
              seekerr = fseek(classfile, 4, SEEK_CUR);
              break;
      case CP_LONG:
      case CP_DOUBLE:
              seekerr = fseek(classfile, 8, SEEK_CUR);
              ++(*cur);
              break;
      default:
              corrupt_error();
      }
      if(seekerr)
              seek_error();
}

void error(const char *format, ...)
{
      va_list ap;
      va_start(ap, format);
      vfprintf(stderr, format, ap);
      va_end(ap);
      exit(1);
}

int main(int argc, char **argv)
{
      FILE *classfile;
      u_int16_t cp_count, i, this_class, classinfo_ptr;
      u_int8_t length;

      program = argv[0];

      if(!argv[1])
              error("%s: Missing input file\n", program);
      classfile = fopen(argv[1], "rb");
      if(!classfile)
              error("%s: Error opening %s\n", program, argv[1]);

      if(fseek(classfile, 8, SEEK_SET))  /* skip magic and version numbers */
              seek_error();
      cp_count = read_16(classfile);
      pool = calloc(cp_count, sizeof(long));
      if(!pool)
              error("%s: Out of memory for constant pool\n", program);

      for(i = 1; i < cp_count; ++i)
              skip_constant(classfile, &i);
      if(fseek(classfile, 2, SEEK_CUR))       /* skip access flags */
              seek_error();

      this_class = read_16(classfile);
      if(this_class < 1 || this_class >= cp_count)
              corrupt_error();
      if(!pool[this_class] || pool[this_class] == -1)
              corrupt_error();
      if(fseek(classfile, pool[this_class] + 1, SEEK_SET))
              seek_error();

      classinfo_ptr = read_16(classfile);
      if(classinfo_ptr < 1 || classinfo_ptr >= cp_count)
              corrupt_error();
      if(!pool[classinfo_ptr] || pool[classinfo_ptr] == -1)
              corrupt_error();
      if(fseek(classfile, pool[classinfo_ptr] + 1, SEEK_SET))
              seek_error();

      length = read_16(classfile);
      for(i = 0; i < length; ++i)
      {
              u_int8_t x = read_8(classfile);
              if((x & 0x80) || !x)
              {
                      if((x & 0xE0) == 0xC0)
                      {
                              u_int8_t y = read_8(classfile);
                              if((y & 0xC0) == 0x80)
                              {
                                      int c = ((x & 0x1f) << 6) + (y & 0x3f);
                                      if(c) putchar(c);
                                      else utf8_error();
                              }
                              else utf8_error();
                      }
                      else utf8_error();
              }
              else if(x == '/') putchar('.');
              else putchar(x);
      }
      putchar('\n');
      free(pool);
      fclose(classfile);
      return 0;
}

jarwrapper

#!/bin/bash
# /usr/local/java/bin/jarwrapper - the wrapper for binfmt_misc/jar

java -jar $1

現在只需 chmod +x 您想要執行的 .class、.jar 和/或 .html 檔案。

要將 Java 程式新增到您的路徑，最好將指向主 .class 檔案的符號連結放入 /usr/bin（或您喜歡的其他位置），省略 .class 副檔名。 包含原始 .class 檔案的目錄將在執行期間新增到您的 CLASSPATH。

要測試您的新設定，請輸入以下簡單的 Java 應用程式，並將其命名為“HelloWorld.java”

class HelloWorld {
        public static void main(String args[]) {
                System.out.println("Hello World!");
        }
}

現在用以下命令編譯應用程式

javac HelloWorld.java

使用以下命令設定二進位制檔案的可執行許可權

chmod 755 HelloWorld.class

然後執行它

./HelloWorld.class

要執行 Java Jar 檔案，只需 chmod *.jar 檔案以包含執行位，然後只需執行

./Application.jar

要執行 Java Applet，只需 chmod *.html 檔案以包含執行位，然後只需執行

./Applet.html

最初由 Brian A. Lantz, brian@lantz.com 編寫，由 Richard Günther 大量編輯以用於 binfmt_misc， Colin J. Watson <cjw44@cam.ac.uk> 添加了新指令碼，Kurt Huwig <kurt@iku-netz.de> 添加了可執行 Jar 檔案支援