projects/linux·blob v7.3 · refs

423 lines · 10.9 KiB

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 <[email protected]>.
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 <[email protected]>.
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, [email protected]
421heavily edited for binfmt_misc by Richard Günther
422new scripts by Colin J. Watson <[email protected]>
423added executable Jar file support by Kurt Huwig <[email protected]>