1Java(tm) Binary Kernel Support for Linux v1.03
2----------------------------------------------
3
4Linux beats them ALL! While all other OS's are TALKING about direct
5support of Java Binaries in the OS, Linux is doing it!
6
7You can execute Java applications and Java Applets just like any
8other program after you have done the following:
9
101) 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
212) You have to compile BINFMT_MISC either as a module or into
22   the kernel (``CONFIG_BINFMT_MISC``) and set it up properly.
23   If you choose to compile it as a module, you will have
24   to insert it manually with modprobe/insmod, as kmod
25   cannot easily be supported with binfmt_misc.
26   Read the file 'binfmt_misc.txt' in this directory to know
27   more about the configuration process.
28
293) Add the following configuration items to binfmt_misc
30   (you should really have read ``binfmt_misc.txt`` now):
31   support for Java applications::
32
33     ':Java:M::\xca\xfe\xba\xbe::/usr/local/bin/javawrapper:'
34
35   support for executable Jar files::
36
37     ':ExecutableJAR:E::jar::/usr/local/bin/jarwrapper:'
38
39   support for Java Applets::
40
41     ':Applet:E::html::/usr/bin/appletviewer:'
42
43   or the following, if you want to be more selective::
44
45     ':Applet:M::<!--applet::/usr/bin/appletviewer:'
46
47   Of course you have to fix the path names. The path/file names given in this
48   document match the Debian 2.1 system. (i.e. jdk installed in ``/usr``,
49   custom wrappers from this document in ``/usr/local``)
50
51   Note, that for the more selective applet support you have to modify
52   existing html-files to contain ``<!--applet-->`` in the first line
53   (``<`` has to be the first character!) to let this work!
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
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``.
65
66   Both the javawrapper shellscript and the javaclassname program
67   were supplied by Colin J. Watson <cjw44@cam.ac.uk>.
68
69Javawrapper shell script:
70
71.. code-block:: sh
72
73  #!/bin/bash
74  # /usr/local/bin/javawrapper - the wrapper for binfmt_misc/java
75
76  if [ -z "$1" ]; then
77	exec 1>&2
78	echo Usage: $0 class-file
79	exit 1
80  fi
81
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-/[^/]*$--'`
86
87  # for example:
88  # CLASS=Test.class
89  # FQCLASS=foo.bar.Test
90  # FQCLASSN=Test
91  # FQCLASSP=foo/bar
92
93  unset CLASSBASE
94
95  declare -i LINKLEVEL=0
96
97  while :; do
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/'`
134  done
135
136  if [ -z "$CLASSBASE" ]; then
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
146  fi
147
148  if ! echo $CLASSPATH | grep -q "^\(.*:\)*$CLASSBASE\(:.*\)*"; then
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
155  fi
156
157  shift
158  /usr/bin/java $FQCLASS "$@"
159
160javaclassname.c:
161
162.. code-block:: c
163
164  /* javaclassname.c
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   */
185
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  {
228	int b = fgetc(classfile);
229	if(b == EOF)
230		eof_error();
231	return (u_int8_t)b;
232  }
233
234  /* Reads in an unsigned 16-bit integer. */
235  u_int16_t read_16(FILE *classfile)
236  {
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);
245  }
246
247  /* Reads in a value from the constant pool. */
248  void skip_constant(FILE *classfile, u_int16_t *cur)
249  {
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:
261	case CP_METHODTYPE:
262		seekerr = fseek(classfile, 2, SEEK_CUR);
263		break;
264	case CP_METHODHANDLE:
265		seekerr = fseek(classfile, 3, SEEK_CUR);
266		break;
267	case CP_INTEGER:
268	case CP_FLOAT:
269	case CP_FIELDREF:
270	case CP_METHODREF:
271	case CP_INTERFACEMETHODREF:
272	case CP_NAMEANDTYPE:
273	case CP_INVOKEDYNAMIC:
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();
286  }
287
288  void error(const char *format, ...)
289  {
290	va_list ap;
291	va_start(ap, format);
292	vfprintf(stderr, format, ap);
293	va_end(ap);
294	exit(1);
295  }
296
297  int main(int argc, char **argv)
298  {
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;
365  }
366
367jarwrapper::
368
369  #!/bin/bash
370  # /usr/local/java/bin/jarwrapper - the wrapper for binfmt_misc/jar
371
372  java -jar $1
373
374
375Now simply ``chmod +x`` the ``.class``, ``.jar`` and/or ``.html`` files you
376want to execute.
377
378To 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
380extension. The directory containing the original .class file will be
381added to your CLASSPATH during execution.
382
383
384To test your new setup, enter in the following simple Java app, and name
385it "HelloWorld.java":
386
387.. code-block:: java
388
389	class HelloWorld {
390		public static void main(String args[]) {
391			System.out.println("Hello World!");
392		}
393	}
394
395Now compile the application with::
396
397	javac HelloWorld.java
398
399Set the executable permissions of the binary file, with::
400
401	chmod 755 HelloWorld.class
402
403And then execute it::
404
405	./HelloWorld.class
406
407
408To execute Java Jar files, simple chmod the ``*.jar`` files to include
409the execution bit, then just do::
410
411       ./Application.jar
412
413
414To execute Java Applets, simple chmod the ``*.html`` files to include
415the execution bit, then just do::
416
417	./Applet.html
418
419
420originally by Brian A. Lantz, brian@lantz.com
421heavily edited for binfmt_misc by Richard Günther
422new scripts by Colin J. Watson <cjw44@cam.ac.uk>
423added executable Jar file support by Kurt Huwig <kurt@iku-netz.de>
424