[mirror_ubuntu-bionic-kernel.git] / Documentation / admin-guide / java.rst

Java(tm) Binary Kernel Support for Linux v1.03
----------------------------------------------

Linux beats them ALL! While all other OS's are TALKING about direct
support of Java Binaries in the OS, Linux is doing it!

You can execute Java applications and Java Applets just like any
other program after you have done the following:

1) You MUST FIRST install the Java Developers Kit for Linux.
   The Java on Linux HOWTO gives the details on getting and
   installing this. This HOWTO can be found at:

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

   You should also set up a reasonable CLASSPATH environment
   variable to use Java applications that make use of any
   nonstandard classes (not included in the same directory
   as the application itself).

2) You have to compile BINFMT_MISC either as a module or into
   the kernel (``CONFIG_BINFMT_MISC``) and set it up properly.
   If you choose to compile it as a module, you will have
   to insert it manually with modprobe/insmod, as kmod
   cannot easily be supported with binfmt_misc.
   Read the file 'binfmt_misc.txt' in this directory to know
   more about the configuration process.

3) Add the following configuration items to binfmt_misc
   (you should really have read ``binfmt_misc.txt`` now):
   support for Java applications::

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

   support for executable Jar files::

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

   support for Java Applets::

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

   or the following, if you want to be more selective::

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

   Of course you have to fix the path names. The path/file names given in this
   document match the Debian 2.1 system. (i.e. jdk installed in ``/usr``,
   custom wrappers from this document in ``/usr/local``)

   Note, that for the more selective applet support you have to modify
   existing html-files to contain ``<!--applet-->`` in the first line
   (``<`` has to be the first character!) to let this work!

   For the compiled Java programs you need a wrapper script like the
   following (this is because Java is broken in case of the filename
   handling), again fix the path names, both in the script and in the
   above given configuration string.

   You, too, need the little program after the script. Compile like::

	gcc -O2 -o javaclassname javaclassname.c

   and stick it to ``/usr/local/bin``.

   Both the javawrapper shellscript and the javaclassname program
   were supplied by Colin J. Watson <cjw44@cam.ac.uk>.

Javawrapper shell script:

.. code-block:: sh

  #!/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:

.. code-block:: 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


Now simply ``chmod +x`` the ``.class``, ``.jar`` and/or ``.html`` files you
want to execute.

To add a Java program to your path best put a symbolic link to the main
.class file into /usr/bin (or another place you like) omitting the .class
extension. The directory containing the original .class file will be
added to your CLASSPATH during execution.


To test your new setup, enter in the following simple Java app, and name
it "HelloWorld.java":

.. code-block:: java

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

Now compile the application with::

	javac HelloWorld.java

Set the executable permissions of the binary file, with::

	chmod 755 HelloWorld.class

And then execute it::

	./HelloWorld.class


To execute Java Jar files, simple chmod the ``*.jar`` files to include
the execution bit, then just do::

       ./Application.jar


To execute Java Applets, simple chmod the ``*.html`` files to include
the execution bit, then just do::

	./Applet.html


originally by Brian A. Lantz, brian@lantz.com
heavily edited for binfmt_misc by Richard Günther
new scripts by Colin J. Watson <cjw44@cam.ac.uk>
added executable Jar file support by Kurt Huwig <kurt@iku-netz.de>
Commit	Line	Data
503c5bf9 MCC	1	Java(tm) Binary Kernel Support for Linux v1.03
503c5bf9 MCC	2	----------------------------------------------
1da177e4 LT	3
	4	Linux beats them ALL! While all other OS's are TALKING about direct
	5	support of Java Binaries in the OS, Linux is doing it!
	6
	7	You can execute Java applications and Java Applets just like any
	8	other program after you have done the following:
	9
	10	1) You MUST FIRST install the Java Developers Kit for Linux.
	11	The Java on Linux HOWTO gives the details on getting and
	12	installing this. This HOWTO can be found at:
	13
	14	ftp://sunsite.unc.edu/pub/Linux/docs/HOWTO/Java-HOWTO
	15
	16	You should also set up a reasonable CLASSPATH environment
	17	variable to use Java applications that make use of any
	18	nonstandard classes (not included in the same directory
	19	as the application itself).
	20
	21	2) You have to compile BINFMT_MISC either as a module or into
503c5bf9	22	the kernel (``CONFIG_BINFMT_MISC``) and set it up properly.
1da177e4 LT	23	If you choose to compile it as a module, you will have
1da177e4 LT	24	to insert it manually with modprobe/insmod, as kmod
503c5bf9	25	cannot easily be supported with binfmt_misc.
1da177e4 LT	26	Read the file 'binfmt_misc.txt' in this directory to know
	27	more about the configuration process.
	28
	29	3) Add the following configuration items to binfmt_misc
503c5bf9 MCC	30	(you should really have read ``binfmt_misc.txt`` now):
	31	support for Java applications::
	32
1da177e4	33	':Java:M::\xca\xfe\xba\xbe::/usr/local/bin/javawrapper:'
503c5bf9 MCC	34
	35	support for executable Jar files::
	36
1da177e4	37	':ExecutableJAR:E::jar::/usr/local/bin/jarwrapper:'
503c5bf9 MCC	38
	39	support for Java Applets::
	40
1da177e4	41	':Applet:E::html::/usr/bin/appletviewer:'
503c5bf9 MCC	42
	43	or the following, if you want to be more selective::
	44
1da177e4 LT	45	':Applet:M::<!--applet::/usr/bin/appletviewer:'
1da177e4 LT	46
59dd24d3	47	Of course you have to fix the path names. The path/file names given in this
503c5bf9 MCC	48	document match the Debian 2.1 system. (i.e. jdk installed in ``/usr``,
503c5bf9 MCC	49	custom wrappers from this document in ``/usr/local``)
1da177e4 LT	50
1da177e4 LT	51	Note, that for the more selective applet support you have to modify
503c5bf9 MCC	52	existing html-files to contain ``<!--applet-->`` in the first line
503c5bf9 MCC	53	(``<`` has to be the first character!) to let this work!
1da177e4 LT	54
	55	For the compiled Java programs you need a wrapper script like the
	56	following (this is because Java is broken in case of the filename
	57	handling), again fix the path names, both in the script and in the
	58	above given configuration string.
	59
503c5bf9 MCC	60	You, too, need the little program after the script. Compile like::
	61
	62	gcc -O2 -o javaclassname javaclassname.c
	63
	64	and stick it to ``/usr/local/bin``.
1da177e4 LT	65
	66	Both the javawrapper shellscript and the javaclassname program
	67	were supplied by Colin J. Watson <cjw44@cam.ac.uk>.
	68
07a37ba5 JN	69	Javawrapper shell script:
	70
	71	.. code-block:: sh
503c5bf9 MCC	72
	73	#!/bin/bash
	74	# /usr/local/bin/javawrapper - the wrapper for binfmt_misc/java
1da177e4	75
503c5bf9	76	if [ -z "$1" ]; then
1da177e4 LT	77	exec 1>&2
	78	echo Usage: $0 class-file
	79	exit 1
503c5bf9	80	fi
1da177e4	81
503c5bf9 MCC	82	CLASS=$1
	83	FQCLASS=`/usr/local/bin/javaclassname $1`
	84	FQCLASSN=`echo $FQCLASS \| sed -e 's/^.\.\([^.]\)$/\1/'`
	85	FQCLASSP=`echo $FQCLASS \| sed -e 's-\.-/-g' -e 's-^[^/]$--' -e 's-/[^/]$--'`
1da177e4	86
503c5bf9 MCC	87	# for example:
	88	# CLASS=Test.class
	89	# FQCLASS=foo.bar.Test
	90	# FQCLASSN=Test
	91	# FQCLASSP=foo/bar
1da177e4	92
503c5bf9	93	unset CLASSBASE
1da177e4	94
503c5bf9	95	declare -i LINKLEVEL=0
1da177e4	96
503c5bf9	97	while :; do
1da177e4 LT	98	if [ "`basename $CLASS .class`" == "$FQCLASSN" ]; then
	99	# See if this directory works straight off
	100	cd -L `dirname $CLASS`
	101	CLASSDIR=$PWD
	102	cd $OLDPWD
	103	if echo $CLASSDIR \| grep -q "$FQCLASSP$"; then
	104	CLASSBASE=`echo $CLASSDIR \| sed -e "s.$FQCLASSP$.."`
	105	break;
	106	fi
	107	# Try dereferencing the directory name
	108	cd -P `dirname $CLASS`
	109	CLASSDIR=$PWD
	110	cd $OLDPWD
	111	if echo $CLASSDIR \| grep -q "$FQCLASSP$"; then
	112	CLASSBASE=`echo $CLASSDIR \| sed -e "s.$FQCLASSP$.."`
	113	break;
	114	fi
	115	# If no other possible filename exists
	116	if [ ! -L $CLASS ]; then
	117	exec 1>&2
	118	echo $0:
	119	echo " $CLASS should be in a" \
	120	"directory tree called $FQCLASSP"
	121	exit 1
	122	fi
	123	fi
	124	if [ ! -L $CLASS ]; then break; fi
	125	# Go down one more level of symbolic links
	126	let LINKLEVEL+=1
	127	if [ $LINKLEVEL -gt 5 ]; then
	128	exec 1>&2
	129	echo $0:
	130	echo " Too many symbolic links encountered"
	131	exit 1
	132	fi
	133	CLASS=`ls --color=no -l $CLASS \| sed -e 's/^.* \([^ ]*\)$/\1/'`
503c5bf9	134	done
1da177e4	135
503c5bf9	136	if [ -z "$CLASSBASE" ]; then
1da177e4 LT	137	if [ -z "$FQCLASSP" ]; then
	138	GOODNAME=$FQCLASSN.class
	139	else
	140	GOODNAME=$FQCLASSP/$FQCLASSN.class
	141	fi
	142	exec 1>&2
	143	echo $0:
	144	echo " $FQCLASS should be in a file called $GOODNAME"
	145	exit 1
503c5bf9	146	fi
1da177e4	147
503c5bf9	148	if ! echo $CLASSPATH \| grep -q "^\(.:\)$CLASSBASE\(:.\)"; then
1da177e4 LT	149	# class is not in CLASSPATH, so prepend dir of class to CLASSPATH
	150	if [ -z "${CLASSPATH}" ] ; then
	151	export CLASSPATH=$CLASSBASE
	152	else
	153	export CLASSPATH=$CLASSBASE:$CLASSPATH
	154	fi
503c5bf9	155	fi
1da177e4	156
503c5bf9 MCC	157	shift
503c5bf9 MCC	158	/usr/bin/java $FQCLASS "$@"
1da177e4	159
07a37ba5 JN	160	javaclassname.c:
	161
	162	.. code-block:: c
1da177e4	163
503c5bf9	164	/* javaclassname.c
07a37ba5 JN	165	*
	166	* Extracts the class name from a Java class file; intended for use in a Java
	167	* wrapper of the type supported by the binfmt_misc option in the Linux kernel.
	168	*
	169	* Copyright (C) 1999 Colin J. Watson <cjw44@cam.ac.uk>.
	170	*
	171	* This program is free software; you can redistribute it and/or modify
	172	* it under the terms of the GNU General Public License as published by
	173	* the Free Software Foundation; either version 2 of the License, or
	174	* (at your option) any later version.
	175	*
	176	* This program is distributed in the hope that it will be useful,
	177	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	178	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	179	* GNU General Public License for more details.
	180	*
	181	* You should have received a copy of the GNU General Public License
	182	* along with this program; if not, write to the Free Software
	183	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	184	*/
1da177e4	185
503c5bf9 MCC	186	#include <stdlib.h>
	187	#include <stdio.h>
	188	#include <stdarg.h>
	189	#include <sys/types.h>
	190
	191	/* From Sun's Java VM Specification, as tag entries in the constant pool. */
	192
	193	#define CP_UTF8 1
	194	#define CP_INTEGER 3
	195	#define CP_FLOAT 4
	196	#define CP_LONG 5
	197	#define CP_DOUBLE 6
	198	#define CP_CLASS 7
	199	#define CP_STRING 8
	200	#define CP_FIELDREF 9
	201	#define CP_METHODREF 10
	202	#define CP_INTERFACEMETHODREF 11
	203	#define CP_NAMEANDTYPE 12
	204	#define CP_METHODHANDLE 15
	205	#define CP_METHODTYPE 16
	206	#define CP_INVOKEDYNAMIC 18
	207
	208	/* Define some commonly used error messages */
	209
	210	#define seek_error() error("%s: Cannot seek\n", program)
	211	#define corrupt_error() error("%s: Class file corrupt\n", program)
	212	#define eof_error() error("%s: Unexpected end of file\n", program)
	213	#define utf8_error() error("%s: Only ASCII 1-255 supported\n", program);
	214
	215	char *program;
	216
	217	long *pool;
	218
	219	u_int8_t read_8(FILE *classfile);
	220	u_int16_t read_16(FILE *classfile);
	221	void skip_constant(FILE classfile, u_int16_t cur);
	222	void error(const char *format, ...);
	223	int main(int argc, char **argv);
	224
	225	/* Reads in an unsigned 8-bit integer. */
	226	u_int8_t read_8(FILE *classfile)
	227	{
1da177e4 LT	228	int b = fgetc(classfile);
	229	if(b == EOF)
	230	eof_error();
	231	return (u_int8_t)b;
503c5bf9	232	}
1da177e4	233
503c5bf9 MCC	234	/* Reads in an unsigned 16-bit integer. */
	235	u_int16_t read_16(FILE *classfile)
	236	{
1da177e4 LT	237	int b1, b2;
	238	b1 = fgetc(classfile);
	239	if(b1 == EOF)
	240	eof_error();
	241	b2 = fgetc(classfile);
	242	if(b2 == EOF)
	243	eof_error();
	244	return (u_int16_t)((b1 << 8) \| b2);
503c5bf9	245	}
1da177e4	246
503c5bf9 MCC	247	/* Reads in a value from the constant pool. */
	248	void skip_constant(FILE classfile, u_int16_t cur)
	249	{
1da177e4 LT	250	u_int16_t len;
	251	int seekerr = 1;
	252	pool[*cur] = ftell(classfile);
	253	switch(read_8(classfile))
	254	{
	255	case CP_UTF8:
	256	len = read_16(classfile);
	257	seekerr = fseek(classfile, len, SEEK_CUR);
	258	break;
	259	case CP_CLASS:
	260	case CP_STRING:
f76f133b	261	case CP_METHODTYPE:
1da177e4 LT	262	seekerr = fseek(classfile, 2, SEEK_CUR);
1da177e4 LT	263	break;
f76f133b JC	264	case CP_METHODHANDLE:
	265	seekerr = fseek(classfile, 3, SEEK_CUR);
	266	break;
1da177e4 LT	267	case CP_INTEGER:
	268	case CP_FLOAT:
	269	case CP_FIELDREF:
	270	case CP_METHODREF:
	271	case CP_INTERFACEMETHODREF:
	272	case CP_NAMEANDTYPE:
f76f133b	273	case CP_INVOKEDYNAMIC:
1da177e4 LT	274	seekerr = fseek(classfile, 4, SEEK_CUR);
	275	break;
	276	case CP_LONG:
	277	case CP_DOUBLE:
	278	seekerr = fseek(classfile, 8, SEEK_CUR);
	279	++(*cur);
	280	break;
	281	default:
	282	corrupt_error();
	283	}
	284	if(seekerr)
	285	seek_error();
503c5bf9	286	}
1da177e4	287
503c5bf9 MCC	288	void error(const char *format, ...)
503c5bf9 MCC	289	{
1da177e4 LT	290	va_list ap;
	291	va_start(ap, format);
	292	vfprintf(stderr, format, ap);
	293	va_end(ap);
	294	exit(1);
503c5bf9	295	}
1da177e4	296
503c5bf9 MCC	297	int main(int argc, char **argv)
503c5bf9 MCC	298	{
1da177e4 LT	299	FILE *classfile;
	300	u_int16_t cp_count, i, this_class, classinfo_ptr;
	301	u_int8_t length;
	302
	303	program = argv[0];
	304
	305	if(!argv[1])
	306	error("%s: Missing input file\n", program);
	307	classfile = fopen(argv[1], "rb");
	308	if(!classfile)
	309	error("%s: Error opening %s\n", program, argv[1]);
	310
	311	if(fseek(classfile, 8, SEEK_SET)) /* skip magic and version numbers */
	312	seek_error();
	313	cp_count = read_16(classfile);
	314	pool = calloc(cp_count, sizeof(long));
	315	if(!pool)
	316	error("%s: Out of memory for constant pool\n", program);
	317
	318	for(i = 1; i < cp_count; ++i)
	319	skip_constant(classfile, &i);
	320	if(fseek(classfile, 2, SEEK_CUR)) /* skip access flags */
	321	seek_error();
	322
	323	this_class = read_16(classfile);
	324	if(this_class < 1 \|\| this_class >= cp_count)
	325	corrupt_error();
	326	if(!pool[this_class] \|\| pool[this_class] == -1)
	327	corrupt_error();
	328	if(fseek(classfile, pool[this_class] + 1, SEEK_SET))
	329	seek_error();
	330
	331	classinfo_ptr = read_16(classfile);
	332	if(classinfo_ptr < 1 \|\| classinfo_ptr >= cp_count)
	333	corrupt_error();
	334	if(!pool[classinfo_ptr] \|\| pool[classinfo_ptr] == -1)
	335	corrupt_error();
	336	if(fseek(classfile, pool[classinfo_ptr] + 1, SEEK_SET))
	337	seek_error();
	338
	339	length = read_16(classfile);
	340	for(i = 0; i < length; ++i)
	341	{
	342	u_int8_t x = read_8(classfile);
	343	if((x & 0x80) \|\| !x)
	344	{
	345	if((x & 0xE0) == 0xC0)
	346	{
	347	u_int8_t y = read_8(classfile);
	348	if((y & 0xC0) == 0x80)
	349	{
	350	int c = ((x & 0x1f) << 6) + (y & 0x3f);
	351	if(c) putchar(c);
	352	else utf8_error();
	353	}
	354	else utf8_error();
	355	}
	356	else utf8_error();
	357	}
	358	else if(x == '/') putchar('.');
	359	else putchar(x);
	360	}
	361	putchar('\n');
	362	free(pool);
363	fclose(classfile);
364	return 0;
503c5bf9	365	}
1da177e4	366
503c5bf9	367	jarwrapper::
1da177e4	368
503c5bf9 MCC	369	#!/bin/bash
503c5bf9 MCC	370	# /usr/local/java/bin/jarwrapper - the wrapper for binfmt_misc/jar
1da177e4	371
503c5bf9	372	java -jar $1
1da177e4 LT	373
1da177e4 LT	374
503c5bf9 MCC	375	Now simply ``chmod +x`` the ``.class``, ``.jar`` and/or ``.html`` files you
	376	want to execute.
	377
1da177e4 LT	378	To add a Java program to your path best put a symbolic link to the main
	379	.class file into /usr/bin (or another place you like) omitting the .class
	380	extension. The directory containing the original .class file will be
	381	added to your CLASSPATH during execution.
	382
	383
	384	To test your new setup, enter in the following simple Java app, and name
07a37ba5 JN	385	it "HelloWorld.java":
	386
	387	.. code-block:: java
1da177e4 LT	388
	389	class HelloWorld {
	390	public static void main(String args[]) {
	391	System.out.println("Hello World!");
	392	}
	393	}
	394
503c5bf9 MCC	395	Now compile the application with::
503c5bf9 MCC	396
1da177e4 LT	397	javac HelloWorld.java
1da177e4 LT	398
503c5bf9 MCC	399	Set the executable permissions of the binary file, with::
503c5bf9 MCC	400
1da177e4 LT	401	chmod 755 HelloWorld.class
1da177e4 LT	402
503c5bf9 MCC	403	And then execute it::
503c5bf9 MCC	404
1da177e4 LT	405	./HelloWorld.class
	406
	407
503c5bf9 MCC	408	To execute Java Jar files, simple chmod the ``*.jar`` files to include
	409	the execution bit, then just do::
	410
1da177e4 LT	411	./Application.jar
	412
	413
503c5bf9 MCC	414	To execute Java Applets, simple chmod the ``*.html`` files to include
	415	the execution bit, then just do::
	416
1da177e4 LT	417	./Applet.html
	418
	419
	420	originally by Brian A. Lantz, brian@lantz.com
be2a608b	421	heavily edited for binfmt_misc by Richard Günther
1da177e4 LT	422	new scripts by Colin J. Watson <cjw44@cam.ac.uk>
1da177e4 LT	423	added executable Jar file support by Kurt Huwig <kurt@iku-netz.de>