IBM^(R) Developer Kit for Linux, Java^(TM) 2 Technology Edition, Version 1.3.1, 32-bit version
- README -

Note: Before using this information and the product it supports, be sure to read the general information under Notices.

This edition of the README applies to the IBM Developer Kit for Linux, Java 2 Technology Edition, Version 1.3.1, 32-bit version, and to all subsequent releases and modifications until otherwise indicated in new editions.

(c) Copyright International Business Machines Corporation, 1999, 2002. All rights reserved.

(c) Copyright Sun Microsystems, Inc. 1997, 2001, 901 San Antonio Rd., Palo Alto, CA 94303 USA. All rights reserved.

U.S. Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

This README file provides information about the IBM^(R) Developer Kit for Linux, Java^(TM) 2 Technology Edition, Version 1.3.1, 32-bit version (Developer Kit for Linux).

The Developer Kit for Linux enables you to write and then run Java applications and applets. Note that the Runtime Environment for Linux is a subset of this Developer Kit and enables you only to run Java applications. If you have installed the Developer Kit for Linux, you do not need the Runtime Environment.

For the list of distributions against which the Developer Kit for Linux has been tested, see:
http://www-106.ibm.com/developerworks/java/jdk/linux/tested.html

Contents

The Developer Kit for Linux is a development environment for writing applets and applications that conform to Sun Microsystems Java 1.3 Core Application Programming Interface (API).

In general, any applet or application that runs in Version 1.1.8 of the Developer Kit for Linux should run correctly in this version. Applets that depend on Sun's Java 1.3.1 APIs work only on browsers that support Java 1.3.1 APIs.

To read Sun's documentation on compatibility, search for it on the Sun Web site at http://java.sun.com.

Contents of the Developer Kit for Linux

The following list describes the contents of the Developer Kit package.

• RUNTIME Environment - Classes (rt.jar)
  This file contains all of the compiled .class files for the platform and must remain zipped for the compiler and interpreter to properly access the class files within it.

• TOOLS
  The tools provided include:

  • Java Compiler (javac)

    Compiles programs written in the Java programming language into bytecodes (compiled Java code).

  • Java Interpreter (java)

    Executes Java bytecodes. The Java Interpreter runs programs written in the Java programming language.

  • Java Applet Viewer (appletviewer)

    Use for testing and running applets.

  • Java Debugger (jdb)

    Helps debug your Java programs.

  • Class File Disassembler (javap)

    Disassembles compiled files and prints a representation of the bytecodes.

  • Java Documentation Generator (javadoc)

    Parses the declarations and documentation comments in a set of source files and produces a set of HTML pages describing the public and protected classes, interfaces, constructors, methods, and fields. Also produces a class hierarchy and an index of all members.

  • C Header and Stub File Generator (javah)

    Attaches native methods to code written in the Java programming language.

  • Java Archive Tool (jar)

    Generates signatures for Java Archive (JAR) files, and verifies the signatures of signed JAR files.

  • JAR Signing and Verification Tool (jarsigner)

    Manages entities, including their keys, certificates, and the trust associated with them.

  • Key and Certificate Management Tool (keytool)

    Manages a keystore (database) of private keys and their associated X.509 certificate chains authenticating the corresponding public keys.

  • Policy File Creation and Management Tool (policytool)

    Creates and modifies the external policy configuration files that define your installation's Java security policy.

  • Native-To-ASCII Converter (native2ascii)

    Converts a native encoding file to an ASCII file that includes the \udddd Unicode notation.

  • Java Remote Method Invocation (RMI) Stub Converter (rmic)

    Generates objects from the names of compiled classes that contain remote object implementations. Includes RMI over Internet Inter-ORB Protocol (IIOP), or RMI-IIOP, support.

  • RMI activation system daemon (rmid)

    Starts the activation system daemon so that objects can be registered and activated in a Java virtual machine (JVM).

  • IDL to Java Compiler (idlj)

    Compiles Object Management Group (OMG) Interface Definition Language (IDL) files to Java code.

  • Common Object Request Broker Architecture (CORBA) Naming Service (tnameserv)

    Starts the CORBA transient naming service.

  • Java Remote Object Registry (rmiregistry)

    Creates and starts a remote object registry on the specified port of the current host.

  • Serial Version Command (serialver)

    Returns the serialVersionUID for one or more classes in a form that is suitable for copying into an evolving class.

  • Extcheck utility (extcheck)

    Detects version conflicts between a target jar file and currently installed extension jar files.

  • Various C libraries and include files.

• JAVA DOCUMENTATION AND DEMOS

  The demo directory contains a number of subdirectories containing sample source code, demos, applications, and applets, which you may use.

• README:

  This file.

• COPYRIGHT:

  Copyright notice for the Developer Kit for Linux software.

• LICENSE:

  The LICENSE_xx.html file contains the license agreement for the Developer Kit for Linux software. (xx is an abbreviation for the language.)

  To view or print the license agreement, open the file in a Web browser.

• FIXES.LST:

  A text file that describes any defects fixed after the initial release of this version.

Note: This README file and the accompanying license, copyright files, and demo directory are the only documentation included in this Developer Kit for Linux. You can view Sun's software documentation by visiting the Sun Web site, or you can download Sun's Software documentation package from the Sun Web site http://java.sun.com.

The documentation package is designed to be extracted into the Developer Kit for Linux software installation directory. If you download the zip file archive version, be sure to preserve the file path names when you extract the files from the archive. If you use pkunzip, specify the -d option.

The Developer Kit for Linux includes the IBM just-in-time (JIT) compiler (libjitc.so). The JIT compiler dynamically generates machine code for frequently-used bytecode sequences in a Java application or applet while it is running.

All Developer Kit for Linux tools use the JIT by default. You can disable the JIT to help isolate a problem with a Java application, an applet, or the compiler itself. To disable the JIT, type the following at a shell prompt.

    export JAVA_COMPILER=NONE

To enable the JIT, type the following at a shell prompt:

    export JAVA_COMPILER=jitc

To determine if the JIT is enabled, type the following at a shell prompt:

java -version

If a JIT is in use, one of the following messages is displayed:

• (JIT enabled: jitc)
• compiler = enabled: jitc

If no JIT is in use, one of the following messages is displayed:

• (JIT disabled)
• compiler = disabled

After you install the Developer Kit for Linux, edit your shell script and add to your PATH statement the directory where you installed the Developer Kit. For more information about the PATH statement, see PATH considerations.

The Java Plug-in is a Web browser plug-in for use with Netscape Communicator for Linux. If you use the Java Plug-in, you can bypass your Web browser's default Java Virtual Machine and use instead a Java Runtime Environment (JRE) for running applets or beans in the browser.

To install and configure the Java Plug-in:

• If you are logged on as user ID root, make a symbolic link from /opt/IBMJava2-131/jre/bin/javaplugin.so to one of the following directories:
  • /usr/lib/netscape/plugins - if you want to make the Java Plug-in available to all users on the system
  • $HOME/.netscape/plugins - if you want to make the Java Plug-in available only to user ID root

• If you are not logged on as user ID root:
  1. Create a directory called plugins under the /$HOME/.netscape directory if it does not already exist.
  2. Make a symbolic link from /opt/IBMJava2-131/jre/bin/javaplugin.so to /$HOME/.netscape/plugins.

  Note: The first time you start Netscape after you have linked the javaplugin.so file to the netscape/plugins directory, Netscape will immediately shut down. (If you started Netscape from the command line, a Bus error message is displayed.) You can safely ignore this message because Netscape will not encounter this error after the first time.

Installing on Red Hat

When you are installing on a Red Hat system, to allow the font server to find the Java TrueType fonts, run:

You must do this at install time and you must be root to run the command.

Installing on SuSE

If you are running a SuSE system, there may be a version of this Developer Kit already installed. If this version was supplied by SuSE, it will have been packaged so that it installs under a different directory tree. To avoid unexpected results, you should use YaST2 to remove the SuSE-supplied Developer Kit.

Installing if using BEA Weblogic

If you intend to use the BEA Weblogic server, when you install the Developer Kit for Linux packages you must not install the IBMJava2-JAAS-*.rpm. The BEA Weblogic server contains its own implementation of JAAS.

The process you use to remove the Developer Kit for Linux depends on whether you installed the RPM package or the compressed TAR package. See Uninstalling the RPM package or Uninstalling the compressed TAR package for instructions.

Uninstalling the RPM package

To uninstall the Developer Kit for Linux if you installed the RPM package:

1. At a prompt, type the following:

       rpm -qa | grep IBM
   

   The name of the package is displayed.

2. Use the rpm command, as follows:

       rpm -e pkgname
   

   where pkgname is the name of the package that was displayed.

3. Remove from your PATH statement the directory where you installed the Developer Kit.

4. If you installed the Java Plug-in, remove the Java Plug-in files from the Netscape directory.

To uninstall the Developer Kit for Linux if you installed the compressed TAR package:

1. Remove the Developer Kit files from the directory where you installed the Developer Kit.

2. Remove from your PATH statement the directory where you installed the Developer Kit.

3. If you installed the Java Plug-in, remove the Java Plug-in files from the Netscape directory.

The Java tools are programs that are run from a shell prompt; they do not have a Graphical User Interface (GUI).

The following sections give information on using the Developer Kit for Linux.

After installing the Developer Kit for Linux software, you can run a tool by typing its name at a shell prompt with a filename as an argument.

You can specify the path to a tool by typing the path before the name of the tool each time. For example, if the Developer Kit for Linux software is installed in /opt/IBMJava2-131/bin, you can compile a file named myfile.java by typing the following at a shell prompt:

  /opt/IBMJava2-131/bin/javac myfile.java

To avoid typing the full path each time:

1. Add the following directories to the PATH environment variable:
   • /opt/IBMJava2-131/bin
   • /opt/IBMJava2-131/jre/bin

2. Compile the file with the javac tool. For example, compile the file myfile.java by typing the following at a shell prompt:

     javac myfile.java
   

The PATH environment variable enables Linux to find executable files, such as javac, java, and javadoc, from any current directory. To display the current value of your PATH, type the following at a shell prompt:

  echo $PATH

To change the PATH environment variable:

1. Edit your shell startup file (usually .bash_profile, .profile, or .login depending on the shell) and add to the PATH environment variable the absolute paths to the following directories:
   • /opt/IBMJava2-131/bin
   • /opt/IBMJava2-131/jre/bin
2. Log on again or run the updated shell script to activate the new PATH setting.

The CLASSPATH tells the Developer Kit for Linux tools, such as java, javac, and javadoc, where to find the Java class libraries. If you keep the bin and lib directories under the same parent directory level, the executable files can find the classes.

You need to explicitly set the CLASSPATH only if one of the following applies:

• You require a different library, such as one you develop.
• You change the location of the bin and lib directories such that they no longer have the same common parent directory.
• You plan to develop or run applications using different runtime environments on the same system.
• You are running TurboLinux.

To display the current value of your CLASSPATH, type the following at a shell prompt:

  echo $CLASSPATH

If you plan to develop and run applications using different runtime environments, including other versions that you have installed separately, you need to explicitly set the CLASSPATH (and PATH) appropriately for each application. If you plan to simultaneously run multiple applications using different runtime environments, make sure each application is run in its own shell.

If you want to run only one version of Java at a time, a shell script can be used to switch between the different runtime environments.

With the Applet Viewer, you can run one or more applets that are called by reference in a Web page (HTML file) using the APPLET tag. The Applet Viewer finds the APPLET tags in the HTML file and runs the applets, in separate windows, as specified by the tags.

Because the Applet Viewer is for viewing applets, it cannot display an entire Web page that contains numerous HTML tags. It parses only the APPLET tag and no other HTML on the Web page.

To run an applet with the Applet Viewer, type the following at a shell prompt:

   appletviewer name

where name is one of the following:

• The file name of an HTML file that calls an applet
• The URL of a Web page that calls an applet

For example, to invoke the Applet Viewer on an HTML file that calls an applet, type the following at a shell prompt:

  appletviewer $HOME/filename.html

For example, http://java.sun.com/applets/NervousText/example1.html is the URL of a Web page that calls an applet. To invoke the Applet Viewer on this Web page, type the following at a shell prompt:

  appletviewer http://java.sun.com/applets/NervousText/example1.html

You can debug applets using the -debug option of Applet Viewer. When debugging applets, it is best to invoke Applet Viewer from the directory that contains the HTML file that calls the applet. For example:

     cd demo/TicTacToe
     ../../bin/appletviewer -debug example1.html

You might find documentation on the debugger and its API at the following Sun Web site:

http://java.sun.com/j2se/1.3/docs/guide/jpda

To obtain the IBM build and version number, type the following at a shell prompt:

java -version

Certain Linux distributions - Red Hat, for example - have enabled a GLIBC feature called 'floating stacks'. Because of Linux kernel limitations, the JVM will not run on SMP hardware with floating stacks enabled if the kernel level is less than 2.4.10. In this environment, floating stacks must be disabled before the JVM, or any application that starts the JVM, is started. On Red Hat, you disable floating stacks by exporting an environment variable, thus:

On a non-floating stack Linux system, regardless of what is set for -Xss, a minimum native stack size of 256KB for each thread is provided. On a floating stack Linux system, the -Xss values are honored. Thus, if you are migrating from a non-floating stack Linux system, you must ensure that any -Xss values are large enough and are not relying on a minimum of 256KB.

Debugging Java applications

To debug Java programs, you can use the Java Debugger (JDB). This debugger interfaces with the Java Platform Debugger Architecture (JPDA) provided by the Developer Kit for Linux. For native JNI binary programs, you can still use gdb for debugging.

JPDA

The JPDA classes are included in the tools.jar file, which must be included in the CLASSPATH when running Java programs that use the JPDA (for example, JDB). Only socket communication is supported on Linux.

JDB

A new JDB debugger is included in the Developer Kit for Linux. The JDB starts com.sun.tools.example.debug.tty.TTY. The Java Virtual Machine Debugging Interface (JVMDI) is now fully supported. The jdb tool included in earlier versions is now included as oldjdb.

The new JDB uses the JPDA and allows the jdb example tool to attach to a listening Virtual Machine (VM) or to start a new debug session. It is invoked by the jdb command and can be used in the same way that oldjdb works.

You can use the JDB to debug remote Java applications, including Java applications running on remote machines over a TCP/IP link. To debug a remote Java program, start the java program as follows: <

java -Xdebug -Xnoagent -Xrunjdwp:transport=dt_socket,server=y,
suspend=y 
-Djava.compiler=NONE <other args> <myapp> <myapp class args> 

The port on which the JPDA is listening is displayed. At the remote debugging machine, type the following:

jdb -attach <machine name or ip address>:<port>

When you launch a debug session using the dt_socket transport, make sure that the specified ports are actually free to use.

Note: Sun's documentation for using jdb assumes that the JVM to be debugged is a HotSpot JVM. However, IBM implementations of the Java Virtual Machine (JVM) always run as a Classic JVM. When using IBM's jdb therefore, always assume that the -classic option has been implicitly specified and follow the guidance for debugging a Classic JVM. This requires that the -Xnoagent option be specified, unless the agent class is required in which case the -Xbootclasspath option should be specified to explicitly locate it.

The Java Plug-in HTML Converter is a utility that enables you to convert any HTML page that contains applets to a format that can use the Java Plug-in.

For more information or to download the Java Plug-in HTML Converter, see the Sun Web site: http://www.javasoft.com

On double-byte character set (DBCS) systems, if you want to switch the input method, you must set an environment variable that represents the keycode you use for switching. Optionally, you can set another environment variable that represents the modifiers of the keycode.

To specify the keycode to use for switching, set the IBMJAVA_INPUTMETHOD_SWITCHKEY environment variable to some keycode definition in the java.awt.event.KeyEvent class, for example, VK_F4.

Optionally, specify modifiers of the keycode. To specify modifiers of the keycode, set the IBMJAVA_INPUTMETHOD_SWITCHKEY_MODIFIERS environment variable to some combination of the following three mask definitions in the java.awt.event.InputEvent class:

• ALT_MASK
• CTRL_MASK
• SHIFT_MASK

Separate the masks by commas.

For example, you might set the IBMJAVA_INPUTMETHOD_SWITCHKEY_MODIFIERS environment variable to ALT_MASK, CTRL_MASK.

During Java initialization, the two environment variables are stored.

To be sure you have set the environment variables correctly, press a key and check it with the key combination you specified. If it matches, a Java pop-up menu with selectable input methods is displayed.

This Developer Kit does not ship Devanagari fonts (Devamt.ttf and Devamtb.ttf) in the jre/lib/fonts directory. Instead, where appropriate, Java uses the Monotype Unicode fonts (Times New Roman WorldType and Sans Monospace WorldType) shipped with the IBM platform or IBM software product to support Devanagari (Hindi) fonts.

IBM Developer Kit for Linux, Java 2 Technology Edition, Version 1.3.1, 32-bit version (Developer Kit for Linux) adds support for these CORBA specifications:

This Developer Kit supports all versions of GIOP, as defined by chapters 13 and 15 of the CORBA 2.3.1 specification, OMG document formal/99-10-07, which you can obtain from:

http://www.omg.org/cgi-bin/doc?formal/99-10-07

Bi-directional GIOP is not supported.

This Developer Kit supports Portable Interceptors, as defined by the OMG in the document formal/01-09-58, which you can obtain from:

http://www.omg.org/cgi-bin/doc?formal/01-09-58

Portable Interceptors are hooks into the ORB through which ORB services can intercept the normal flow of execution of the ORB.

Several new classes are introduced in the API to support Portable Interceptors. These are:

org.omg.CORBA.LocalObject
org.omg.Dynamic.Parameter
org.omg.IOP.Codec
org.omg.IOP.CodecFactory
org.omg.IOP.CodecFactoryHelper
org.omg.IOP.CodecFactoryOperations
org.omg.IOP.CodecFactoryPackage.UnknownEncoding
org.omg.IOP.CodecOperations
org.omg.IOP.CodecPackage.FormatMismatch
org.omg.IOP.CodecPackage.InvalidTypeForEncoding
org.omg.IOP.CodecPackage.TypeMismatch
org.omg.IOP.ENCODING_CDR_ENCAPS
org.omg.IOP.Encoding
org.omg.IOP.ServiceContext
org.omg.IOP.TaggedComponent
org.omg.IOP.TaggedProfile
org.omg.Messaging.SYNC_NONE
org.omg.Messaging.SYNC_WITH_SERVER
org.omg.Messaging.SYNC_WITH_TARGET
org.omg.Messaging.SYNC_WITH_TRANSPORT
org.omg.PortableInterceptor.ClientRequestInfo
org.omg.PortableInterceptor.ClientRequestInfoOperations
org.omg.PortableInterceptor.ClientRequestInterceptor
org.omg.PortableInterceptor.ClientRequestInterceptorOperations
org.omg.PortableInterceptor.Current
org.omg.PortableInterceptor.CurrentHelper
org.omg.PortableInterceptor.CurrentOperations
org.omg.PortableInterceptor.ForwardRequest
org.omg.PortableInterceptor.IORInfo
org.omg.PortableInterceptor.IORInfoOperations
org.omg.PortableInterceptor.IORInterceptor
org.omg.PortableInterceptor.IORInterceptorOperations
org.omg.PortableInterceptor.Interceptor
org.omg.PortableInterceptor.InterceptorOperations
org.omg.PortableInterceptor.InvalidSlot
org.omg.PortableInterceptor.LOCATION_FORWARD
org.omg.PortableInterceptor.ORBInitInfo
org.omg.PortableInterceptor.ORBInitInfoOperations
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidName
org.omg.PortableInterceptor.ORBInitializer
org.omg.PortableInterceptor.ORBInitializerOperations
org.omg.PortableInterceptor.PolicyFactory
org.omg.PortableInterceptor.PolicyFactoryOperations
org.omg.PortableInterceptor.RequestInfo
org.omg.PortableInterceptor.RequestInfoOperations
org.omg.PortableInterceptor.SUCCESSFUL
org.omg.PortableInterceptor.SYSTEM_EXCEPTION
org.omg.PortableInterceptor.ServerRequestInfo
org.omg.PortableInterceptor.ServerRequestInfoOperations
org.omg.PortableInterceptor.ServerRequestInterceptor
org.omg.PortableInterceptor.ServerRequestInterceptorOperations
org.omg.PortableInterceptor.TRANSPORT_RETRY
org.omg.PortableInterceptor.USER_EXCEPTION

These classes are not part of the Sun Java 1.3 Core API, and could change in future versions of the IBM Developer Kit.

This Developer Kit has added support for the Interoperable Naming Service, as defined by the OMG in the document ptc/00-08-07, which you can obtain from:

http://www.omg.org/cgi-bin/doc?ptc/00-08-07

The default port used by the Transient Name Server (the tnameserv command), when no ORBInitialPort parameter is given, has changed from 900 to 2809, which is the port number registered with the IANA (Internet Assigned Number Authority) for a CORBA Naming Service. Programs that depend on this default might have to be updated to work with this version.

Several new classes are introduced in the API to support the Interoperable Naming Service:

org.omg.CosNaming.NamingContextExt
org.omg.CosNaming.NamingContextExtHelper
org.omg.CosNaming.NamingContextExtHolder
org.omg.CosNaming.NamingContextExtOperations
org.omg.CosNaming.NamingContextExtPackage.AddressHelper
org.omg.CosNaming.NamingContextExtPackage.InvalidAddress
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHelper
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHolder
org.omg.CosNaming.NamingContextExtPackage.StringNameHelper
org.omg.CosNaming.NamingContextExtPackage.URLStringHelper
org.omg.CosNaming._NamingContextExtImplBase
org.omg.CosNaming._NamingContextExtStub

These classes are not part of the Sun Java 1.3 Core API, and could change in future versions of the IBM Developer Kit.

The initial context returned from the Transient Name Server is now an org.omg.CosNaming.NamingContextExt. Existing programs that narrow the reference to an org.omg.CosNaming.NamingContext will still work, and do not need to be recompiled.

The ORB supports the -ORBInitRef and -ORBDefaultInitRef parameters defined by the Interoperable Naming Service specification, and the ORB::string_to_object operation now supports the ObjectURL string formats (corbaloc: and corbaname:) defined by the Interoperable Naming Service specification.

The OMG specifies a method ORB::register_initial_reference to register a service with the Interoperable Naming Service. However this method is not available in the Sun Java Core API at version 1.3.1. Programs that need to register a service in the current version must invoke this method on the IBM internal ORB implementation class. For example, to register a service "MyService":

where orb is an instance of org.omg.CORBA.ORB, returned from ORB.init(), and serviceRef is a CORBA Object, connected to the ORB. This mechanism is an interim one, and is not compatible with future versions or portable to non-IBM ORBs.

A new runtime debug feature provides improved serviceability. You might find it useful for problem diagnosis or it might be requested by IBM service personnel. Tracing is controlled by three system properties. Set com.ibm.CORBA.Debug=true to turn on tracing. To format and add to the trace GIOP messages sent and received, set com.ibm.CORBA.CommTrace=true. By default, ORB tracing goes to the standard error stream, java.lang.System.err. To direct it to a file, set com.ibm.CORBA.Debug.Output. For example, to trace events and formatted GIOP messages to a file:

The trace will be sent to the files orbtrc.DDMMYYYY.HHmm.SS.txt and orbmsg.DDMMYYYY.HHmm.SS.txt.

Do not turn on tracing for normal operation, because it might cause performance degradation.

The content and format of the trace output could vary from version to version.

The following properties help you to tune the ORB:

• To control GIOP 1.2 fragmentation, set the system property com.ibm.CORBA.FragmentSize. For example, to set the fragment size to 4096 bytes: java -Dcom.ibm.CORBA.FragmentSize=4096 myapp

  The default fragment size is 1024 bytes. You can turn off fragmentation by setting the fragment size to 0.

• In a heterogeneous network, the response to a CORBA Request could be delayed or lost. You can set the maximum time to wait using the system property com.ibm.CORBA.RequestTimeout. Also, you can use com.ibm.CORBA.LocateRequestTimeout to control the timeout for LocateRequests. For example, to restrict both delays to 30 seconds: java -Dcom.ibm.CORBA.RequestTimeout=30 -Dcom.ibm.CORBA.LocateRequestTimeout=30 myapp

  By default, the ORB waits indefinitely for a response. Do not set the timeout too low, or connections might be ended unnecessarily.

• If your program is providing a service in the network, you might have to set to a well-known value the number of the port from which the ORB reads incoming requests. You can control this using the system property com.ibm.CORBA.ListenerPort. For example, to make the ORB use port 1050: java -Dcom.ibm.CORBA.ListenerPort=1050 myapp

  If this property is set, the ORB starts listening as soon as it is initialized. Otherwise, it starts listening only when required.

The following properties may be necessary to enable non-standard behaviour for some vendor ORBs:

• To use the POA ImplicitActivation policy with, for example, older Visibroker ORBs, it may be necessary to set the system property com.ibm.CORBA.POACompatibilityMode=true

  This property causes non-standard system exception, CORBA::OBJ_ADAPTER, to be thrown from org.omg.PortableServer.Servant._get_delegate when the delegate is null, in place of the standard exception CORBA::BAD_INV_ORDER.

  When using an ORB whose POA implementation relies upon receiving the CORBA::OBJ_ADAPTER system exception without this property set, the following failure may be observed: org.omg.CORBA.INTERNAL:org.omg.CORBA.BAD_INV_ORDER: The Servant has not been associated with an ORBinstance

When running with a Java 2 SecurityManager, invocation of some methods in the CORBA API classes might cause permission checks to be made, which could result in a SecurityException. Affected methods include the following:

If your program uses any of these methods, ensure that it is granted the necessary permissions.

The ORB implementation classes in this release are:

org.omg.CORBA.ORBClass=com.ibm.CORBA.iiop.ORB
org.omg.CORBA.ORBSingletonClass=com.ibm.rmi.corba.ORBSingleton
javax.rmi.CORBA.UtilClass=com.ibm.CORBA.iiop.UtilDelegateImpl
javax.rmi.CORBA.StubClass=com.ibm.rmi.javax.rmi.CORBA.StubDelegateImpl
javax.rmi.CORBA.PortableRemoteObjectClass=com.ibm.rmi.javax.rmi.PortableRemoteObject

These are the default values, and you are advised not to set these properties or refer to the implementation classes directly. For portability, make references only to the CORBA API classes, and not to the implementation. Theses values might be changed in future releases.

Thread pooling for RMI Connection Handlers is not enabled by default. To enable the connection pooling implemented at the RMI TCPTransport level, set the option

Java Remote Method Invocation (RMI) provides a simple mechanism to do distributed Java programming. RMI over IIOP (RMI-IIOP) extends the base Java RMI to perform communication using the Common Object Request Broker Architecture (CORBA) standard Internet Inter-ORB Protocol (IIOP protocol). This allows direct interaction with any other CORBA Object Request Brokers (ORBs), whether they were implemented in Java or another programming language.

For information about IBM and RMI-IIOP, see this IBM Web site:

http://www.ibm.com/developerworks/java/rmi-iiop

The following documentation is available:

• The RMI-IIOP Programmer's Guide is an introduction to writing RMI-IIOP programs. The guide is installed when you install the Developer Kit and is on the Web site under "Documents".

• The IDL-to-Java Compiler User's Guide describes how to use the tool that generates Java code from IDL. The guide is installed when you install the Developer Kit and is on the Web site under "Documents".

• The samples directory contains:
  • A "Hello World" example that can switch between the Java Remote Method Protocol (JRMP) and IIOP protocols (demo\rmi-iiop\hello)
  • A "Hello World" example that interacts with a standard IDL program (demo\rmi-iiop\idl)

• The Java Language to IDL Mapping document is a detailed technical specification of RMI-IIOP and can be found at:

  http://www.omg.org/docs/ptc/00-01-06.pdf

The Runtime Environment includes an enhanced BigDecimal class (com.ibm.math.BigDecimal) for Java programming. It is provided (with its supporting class MathContext) as an alternative to the java.math.BigDecimal class.

If you are using the java.math.BigDecimal class in a Java program and you want to access the class, you must change the import statement in your source code as shown:

Change import java.math.*; to import com.ibm.math.*;

You do not need to change any other code.

A Java application, unlike a Java applet, cannot rely on a Web browser for installation and runtime services. When you ship a Java application, your software package probably consists of the following parts:

• Your own class, resource, and data files
• A runtime environment
• An installation procedure or program

To run your application, a user needs the Runtime Environment for Linux. The Developer Kit for Linux software contains a runtime environment. However, you cannot assume that your users have the Developer Kit for Linux software installed.

Your Developer Kit for Linux software license does not allow you to redistribute the Developer Kit for Linux software files. The Runtime Environment for Linux is available for redistribution as a separate package. You can download the Runtime Environment for Linux package from the Web site where you obtained the Developer Kit for Linux package.

If you encounter a problem after you install the Developer Kit for Linux, check the following list:

• Exception when running applets

  If you use the Applet Viewer or the Java Plug-in to run an applet that is in the CLASSPATH, you might get an AccessControlException in Swing. Because the CLASSPATH implicitly contains the current directory (.), this exception might also occur if you run the Java Plug-in in the same directory as the applet class itself.

  To work around this problem, make sure of the following:

  • There are no CLASSPATH references to the applet you are attempting to run in the Java Plug-in or the Applet Viewer.
  • You are not running the applet from the same directory as the class.

• Sound does not work in Java applications

  If sound does not work in your Java applications, your user ID might not have the proper permissions to access the audio device. Change the ownership and permissions of the audio device so that your user ID has the proper permissions.

• Netscape Communicator does not work properly on TurboLinux 6.0

  This problem can be caused because the versions of Netscape Communicator included with TurboLinux 6.0 are for the Linux 2.0 kernel. You can download (and upgrade to) a Linux 2.2 version of Netscape Communicator at the following Netscape Web site:

  http://home.netscape.com

• Unable to load libjava.so library message.

  If you receive a message indicating that the libjava.so library could not be loaded because of a symbol not found (such as __bzero), you might have a down-level version of the GNU C Runtime Library, glibc, installed. The Developer Kit for Linux thread implementation requires glibc version 2.1 or greater.

• Applet Viewer does not load applets.

  If the Applet Viewer does not load applets, type the following at a shell prompt:

      java -verbose sun.applet.AppletViewer
  

  This command lists the classes that are being loaded. From this output, you can determine which class the Applet Viewer is trying to load and where it is trying to load it from. Check to make sure that the class exists and is not damaged in some way.

• Application does not handle EINTR return code correctly

  If you are writing a Java application, particularly a Java Native Interface (JNI) application, be sure that the application handles the EINTR return code correctly; otherwise the application will fail.

• The Java Plug-in does not support printing in this release of the Developer Kit for Linux.

• On the Chinese version of TurboLinux, you must set the LC_ALL environment variable as follows:

      export LC_ALL="POSIX" 
  

• You might not be able to use the system clipboard to copy information between Linux applications and Java applications if you are running KDE as your window manager.

• The Developer Kit for Linux implements Java threads as native threads which results in each thread being a separate Linux process. If the number of Java threads exceeds the maximum number of processes allowed, your program might get an error message, a SIGSEGV error, or simply hang.

  The maximum number of threads available is determined by the minimum of:

  • The user processes setting (ulimit -u) in /etc/security/limits.conf
  • The limit defined in /proc/sys/kernel/threads-max
  • The limit PTHREAD_THREADS_MAX defined in libpthreads.so (change requires glibc to be recompiled)

  However, you might run out of virtual storage prior to reaching the maximum number of threads.

• If a Java application is terminated with a Ctrl-C by the user, a number of processes might be left orphaned.

• The javap program, when run on an interface, duplicates the string "interface" in the result. For example, running javap on "java.lang.Runnable" produces:

       public interface interface java.lang.Runnable extends java.lang.Object...
  

• Displaying dialog boxes created with Swing might result in a noticeable delay of a few seconds before they are actually displayed.

• Key Event results involving the ALT key differ when using different window managers in Linux; they also differ from results in other operating systems. In the Enlightenment window manager, Alt+A and Shift+Alt+A produce different modifiers, and Ctrl+Alt+A produces no key event at all. However, when using the WindowMaker window manager, Ctrl+Alt+A produces a key event.

  On the Linux X Window System, the keymap is set to: 64 0xffe9 (Alt_L) 0xffe7 (Meta_L), and 113 0xffea (Alt_R) 0xffe8 (Meta_R). You can check this by typing the following at a shell prompt:

           xmodmap -pk
  

  This is why the Developer Kit for Linux considers that Meta is being pressed together with Alt. As a workaround, you can remove the Meta_x mapping by typing the following at a shell prompt:

           xmodmap -e "keysym Alt_L = Alt_L" -e "keysym Alt_R = Alt_R"
  

  Note: This workaround might affect other X-Windows applications running on the same display if it uses the Meta-key that was removed.

• The Java Virtual Machine expects the segment selector fs to be preserved across JNI calls. The Java Virtual Machine will fail if fs is not preserved.

• Using OpenLinux e-Server 2.3, Japanese version

  If you are using OpenLinux e-Server 2.3, Japanese version, you must reset some environment variables as follows:

    export CLASSPATH=
    export JAVA_HOME=
  

• Displaying Japanese halfwidth Katakana characters

  If you are using Red Hat Linux 6.2, Japanese version, or OpenLinux e-Server 2.3, Japanese version, halfwidth Katakana characters might not be displayed correctly. This is due to the lack of font data for those characters. If you experience this, download IBM TrueType fonts. Halfwidth Katakana characters can then be displayed on any components except Abstract Windows Toolkit (AWT) Components.

• Passing a Japanese string to a Java applet running with the Java Plug-in

  If you are running a Java applet using the Java Plug-in with Netscape Communicator and you pass a Japanese string as a parameter value, the parameter value is not passed correctly.

• Error when running Netscape Communicator on TurboLinux 6.0J Workstation

  On TurboLinux 6.0J Workstation, you might receive an error message about the libnsfix-ja.so library when using Netscape Communicator.

  To fix the problem, rename the file /usr/lib/netscape/libnsfix-ja.so. The new file name is:

  /usr/lib/netscape/libnsfix-ja.so.org

• Japanese Kana-Kanji conversion users

  On Japanese versions of Linux, you can use a Japanese input method such as Canna, ATOK12(TM) SE, Wnn4(TM), or Wnn6. Use the following sections to avoid problems when using these Japanese input methods.

  For all input method editor (IME) users

  • If you use an IME on a TextArea or a TextField component, the committed text sometimes disappears when you commit the composed text. To avoid this problem, move the mouse pointer away from the composed text and away from the status information line when you commit the composed text. If you do encounter the problem, press the Enter key again, and then the committed text is displayed.

  • If you use an IME on a TextArea or a TextField component, the composed text is sometimes displayed in the wrong position. To avoid this problem, do not change the component position vertically after you commit a string. If you do encounter this problem, re-activate the IME, and then the composed text is displayed at the correct position. The committed text is always displayed at the correct position.

  • If you use an IME with the Sawfish (previously known as Sawmill) window manager, an Input Method Framework (IMF) status window, which is a small window attached to the Java client window, always stays on the top of all the windows on your desktop, even if you switch to another window.

    To bring another window to the top, do one of the following:

    • Minimize the Java client window
    • Drag the Java client window to move it away from the desktop.
  • This JDK might not work properly with kinput2 Version 3.1 alpha1 and beta1 versions. If you experience Input Method problems, use kinput2 version 3, which you can download from the SuSE Web site:

    http://www.suse.com/index_us.html

  Canna users

  If you are using the Canna input method with the kinput2 input method server, some visual feedback from the input method is not visible while you are in KIGOU input mode. To avoid the problem, move the focus onto the client window after the Auxiliary Control Window opens.

  ATOK12 SE users

  • If you are using ATOK12 SE for Linux, composed text might not be committed immediately after you select a candidate in the lookup window. If you continue to input a character, then the committed candidate is displayed.

  • If you are using ATOK12 SE for Linux, changing the input focus between the components neither commits nor flushes the composed text, and you can continue to edit the composed text while other input methods commit or flush the composed text on a focus change.

  Wnn4 users

  If you are using Wnn4, the Enter key does not create a new line and a carriage return while the Input Method Editor (IME) is activated. To create a new line and carriage return, deactivate the IME.

  Wnn6 users

  The xwnmo Input Method server is not supported. Use kinput2 as the Input Method server.

  Wnn4, Wnn6, or Canna users

  If you are using kinput2 as the Input Method server, do not minimize or maximize the Java window in which the kinput2 lookup window is displayed.

  If you minimize the Java window:

  When you restore the Java window you can view the kinput2 lookup window, but you cannot access it. If this occurs, restart your Java application.

  If you maximize the Java window:

  When you restore the Java window the lookup window is sometimes located off the screen. If this occurs, do one of the following:

  • Move the Java window to the top of the screen, and then the lookup window is visible.
  • Reopen the lookup window, and then the lookup window is visible on the screen.

The SDK is provided as is, with no support unless you are entitled by means of an IBM support contract. For information on known problems and FAQs, refer to:

You can report problems to the ibm.software.java.linux news group. This news group is monitored, but solutions to specific reports are not guaranteed. The newsgroup is available from the following news server:

news://news.software.ibm.com

When you report a problem, provide the following information:

1. Describe in detail what you are doing, what you expect to happen, and what is actually happening.

2. Give details of which operating system level and version you are using, window manager name and version, and the output from java -version. uname -a java -version

3. Describe precisely how to reproduce the problem.

4. Include a javacore file either from the application that fails or if this is not possible, from any java application. (A javacore file is generated automatically when there is a failure. You can generate a javacore file by sending a SIGQUIT to the java process. Send a SIGQUIT with CTRL+\ from the command shell, or kill -3 <pid> from the command line.)

5. Make a testcase available. (The simpler the testcase, the faster the problem can be addressed.)

6. If your e-mail address is different from the one given in the newsgroup, provide your e-mail address.

If you are entitled to services for the Program code pursuant to the IBM Solutions Developer Program, contact the IBM Solutions Developer Program through your normal method of access or on the Web at http://www.developer.ibm.com.

If you have purchased a service contract (that is, IBM's Personal Systems Support Line or equivalent service by country), the terms and conditions of that service contract will determine what services, if any, you are entitled to receive with respect to the Program.

The READMEs supplied with this Developer Kit and the Runtime Environment have been tested using screen readers. You can use a screen reader such as the Home Page Reader or the JAWS screen reader with these READMEs.

To change the font sizes in the READMEs, use the function supplied with your browser, usually found under the View menu option.

The Java console does not respond to the tab key for navigation. Use the control-tab key pair to navigate the console.

Policy Tool does not meet accessibility requirements. Policy Tool is used to edit a JVM's security policy files. Because these files are in regular text format, you may edit them with any standard text editor (Notepad on Windows or vi on Unix systems, for example). Information on the policy file location and contents, including required format, can be found at: http://java.sun.com/j2se/1.3/docs/guide/security/PolicyFiles.html.

Information about the permissions granted in a policy file can be found at: http://java.sun.com/j2se/1.3/docs/guide/security/permissions.html

This information was developed for products and services offered in the U.S.A.

IBM may not offer the products, services, or features discussed in this document in other countries. Consult your local IBM representative for information on the products and services currently available in your area. Any reference to an IBM product, program, or service is not intended to state or imply that only that IBM product, program, or service may be used. Any functionally equivalent product, program, or service that does not infringe any IBM intellectual property right may be used instead. However, it is the users responsibility to evaluate and verify the operation of any non-IBM product, program, or service.

IBM may have patents or pending patent applications covering subject matter in this document. The furnishing of this document does not give you any license to these patents. You can send license inquiries, in writing, to:

• IBM Director of Licensing
  IBM Corporation
  North Castle Drive, Armonk
  NY 10504-1758 U.S.A.
  

For license inquiries regarding double-byte (DBCS) information, contact the IBM Intellectual Property Department in your country or send inquiries, in writing, to:

• IBM World Trade Asia Corporation Licensing
  2-31 Roppongi 3-chome, Minato-ku
  Tokyo 106-0032, Japan
  

The following paragraph does not apply to the United Kingdom or any other country where such provisions are inconsistent with local law:

INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS PUBLICATION "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Some states do not allow disclaimer of express or implied warranties in certain transactions, therefore, this statement may not apply to you.

This information could include technical inaccuracies or typographical errors. Changes are periodically made to the information herein; these changes will be incorporated in new editions of the information. IBM may make improvements and/or changes in the product(s) and/or the program(s) described in this information at any time without notice.

Any references in this information to non-IBM Web sites are provided for convenience only and do not in any manner serve as an endorsement of those Web sites. The materials at those Web sites are not part of the materials for this IBM product and use of those Web sites is at your own risk.

IBM may use or distribute any of the information you supply in any way it believes appropriate without incurring any obligation to you.

Licensees of this program who wish to have information about it for the purpose of enabling (i) the exchange of information between independently created programs and other programs (including this one) and (ii) the mutual use of the information which has been exchanged, should contact:

• JTCMAIL@uk.ibm.com
  [Hursley Java Technology Center (JTC) contact]

Such information may be available, subject to appropriate terms and conditions, including in some cases, payment of a fee.

The licensed program described in this document and all licensed material available for it are provided by IBM under terms of the IBM Customer Agreement, IBM International Program License Agreement or any equivalent agreement between us.

Any performance data contained herein was determined in a controlled environment. Therefore, the results obtained in other operating environments may vary significantly. Some measurements may have been made on development-level systems and there is no guarantee that these measurements will be the same on generally available systems. Furthermore, some measurement may have been estimated through extrapolation. Actual results may vary. Users of this document should verify the applicable data for their specific environment.

Information concerning non-IBM products was obtained from the suppliers of those products, their published announcements or other publicly available sources. IBM has not tested those products and cannot confirm the accuracy of performance, compatibility or any other claims related to non-IBM products. Questions on the capabilities of non-IBM products should be addressed to the suppliers of those products.

IBM is a trademark of International Business Machines Corporation in the U.S., or other countries, or both.

Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States, other countries, or both. The Java technology is owned and exclusively licensed by Sun Microsystems, Inc.

Other company, product, and service names may be trademarks or service marks of others.

This product is also based in part on the work of the FreeType Project. For more information about FreeType see http://www.freetype.org.