CVS info: $Revision: 1.1 $ $Date: 2005/03/08 23:50:47 $ $State: Exp $ $Locker: $

Change Log

Version 1.0.1:

- Fixed a bug in `jrpcgen`, which emitted wrong stub code when a remote function contained more than one parameter: in this case, enumerations were not properly coerced to integers (thanks to Michael Smith for pointing this out and at the same time supplying the patch).
- Fixed another bug in `jrpcgen`, which resulted in some (enumeration) constants not being dumped.

Version 1.0.0:

- Tired of all the pre-1.0 releases in the past two years, I finally decided to go straight to the official 1.0 release. The past releases were primarily aiming at feature completeness to some degree, while the real basic parts were quite stable (with few improvements and bug fixes) over time. So, ... we have reached 1.0! ...and will probably soon get to 1.0.x, sigh.
- For XDR structs with tail references to themselves, `jrpcgen` now emits serialization and deserialization code which uses an iteration loop instead of tail recursion. The benefit of this is that the call stack usage is considerably reduced. Of course, this optimization can only be applied if the reference to the same type is the last element of the structure.
- Corrected a race condition, which sometimes caused the listening TCP thread in ONC/RPC servers to die with NullPointerExceptions. Many thanks to Michael Smith for hunting down this one. Classes concerned are `OncRpcTcpConnectionServerTransport`, `OncRpcTcpServerTransport` and `OncRpcUdpServerTransport`.
- jrpcgen now exits the VM with a non-zero return code in case it was called through its statis `main` and jrpcgen stumbled on an error. This allows jrpcgen to be used in classic make projects. The Apache Ant is not affected by this behavior.
- Added an additional constructor to the classes `OncRpcTcpServerTransport` and `OncRpcUdpServerTransport`. It accepts now a local binding address. The server socket is then bound only to this/these local address(es). In addition, `jrpcgen` now emits source code for server stubs with an additional constructor which accepts the additional binding address.

Version 0.95.2:

- Small change in `OncRpcTcpSocketHelper.connect()` to accept a negative timeout that signals to use the particular implementation-specific timeout value.
- Added new constructor to `OncRpcTcpClient`, which accepts a timeout parameter (in milliseconds) as its last argument. This constructor can be used to limit the connection attempt period and finally makes the timeout functionality available which has been implemented in the 0.95.1 release. It is important to note that the timeout specified as the parameter to the constructor does not apply to later ONC/RPC calls. These are controlled as usual through the existing timeout-related accessors.
- Made `OncRpcPortmapClient` a stand-alone class, which is not derived from `OncRpcUdpClient` any more. This now allows applications to contact the portmapper either using UDP/IP or TCP/IP (HTTP not yet supported).
- Bumped up the versioning information in `OncRpcConstants` (I had forgotten to do so for the previous releases...).

Version 0.95.1:

After a long time (and a Ph.D. thesis on metamodelling for communication in operational process control engineering now written and on its way) I've finally managed to get a new RemoteTea release out of the door.

- Implemented timeout-controlled connects for TCP-based ONC/RPC clients. The whole thing is a little bit tricky in view of pre-1.4 JREs. However, I definitely want to support JDK 1.2 and 1.3 (so much for write once, forget everywhere).

  The socket helper object features a `connect` method which can execute timeout-controlled connection establishment. In case the current VM Remote Tea is running on does not provide a proper implementation, Remote Tea resorts to the following algorithm:

  - The `connect` method creates a new thread which in turn tries to connect to the given port at the given host (an instance of the local class `Connectiator` is responsible for this).
  - The original thread initiating the Connectiator thread now waits for it to finish, but no longer than the timeout specified in the call to the `connect` method. In case the Connectiator does not succeed within the timeout period, an `IOException` is thrown by the `connect` method.
  - The Connectiator object will signal itself in case it succeeded, but also if it failed. Its `getIOException` method then either returns `null` or an `IOException`.
- Fixed deserializing bug in `XdrDecodingStream.xdrDecodeLong()`, where unwanted sign extension messed up 64 bit wide integers (XDR hypers).
- Fixed a long-standing "feature" in `XdrTcpDecodingStream.fill()`, which caused invalid header decoding if the fragment length was larger than 227.
- Fixed sanity checks for those ONC/RPC partners sending empty XDR fragments as last fragments of XDR records -- a trailing last XDR fragment that carries no data is now accepted. The fix concerns the class `XdrTcpDecodingStream` semantics of the `fill` method were slightly changed to return also in case of empty trailing record (`lastFragment` attribute must be `true`). All methods directly calling `fill` have been adapted (at least I hope so).
- Improved handling of wrong or mismatching ONC/RPC messages for UDP-based ONC/RPC clients. They do not emit new calls any more when receiving replies from wrong sources and keep quiet instead until the timeout expires (as per current timeout strategy).
- Fixed some buffer offset bugs (forgot to take care of CRLF at one place) in `XdrHttpDecodingStream`, for which patches were kindly offered by the austrian internet chamoises.
- Added Ant task for Jrpcgen as org.acplt.oncrpc.ant.JrpcgenTask, kindly provided by Jean-Francois Daune. This also involved some small changes to jrpcgen in order to make it available as a task.

Version 0.94.2:

- Fixed bug in jrpcgen, which caused a crash when hashing a union's structure (needed to create serial version UIDs) and the union contained a non-empty default arm. Also added appropriate "test case" to demo.x.

Version 0.94.1:

- Added two new code generation options to jrpcgen:
  - `-ser`: tag classes generated for XDR structs, XDR unions and XDR typedefs as serializable. Also automatically generates `serialVersionUID` using the SHA-1 algorithm. (My thanks to the GNU classpath project for providing the SHA-1 algorithm, please see JrpcgenSHA.java for license details).
  - `-initstrings`: automatically initialize all `Strings` as empty strings (""). Note that this may lead to lazy programming; better make explicitly sure that every member of a struct gets initialized properly before encoding the struct.

Version 0.93.1:

- Once more fixed support for JDK 1.1 for Java-based ONC/RPC servers: the old code still used a LinkedList, which is only available since JDK 1.2. So I added a minimalist double linked list local class (it's in `OncRpcTcpServerTransport.TransportList`).
- Worked around some broken JDKs 1.1 (especially on AIX, but I have also heard of problems on Linux), which have broken `InetAddress.getLocalHost`. The code now uses `InetAdress.getByName("127.0.0.1")`. Yeah, write once, does not work anywhere.
- Added overloaded `client.call` method which expects an additional (procedure/protocol) version number as its second argument. This method is necessary so several versions can coexists peacefully in one client and can be called simultaneously. As before, if you do not specify a version in the call to `client.call` the "default" version is used as specified in the constructor. Please note that `OncRpcClient`-derived classes must now implement the overloaded `call` method expecting four parameters: procedure number, version number, parameters, and result (this only applies to those who want to implement their own ONC/RPC clients for different transports than those already provided).
- Added support for multiple parameters in procedure declarations within x-files, to be more in sync with newer rpcgen releases. In addition, jrpcgen now also accept named parameters in remote procedure declarations. Both enhancements caused quite some changes in the code emitting parts of jrpcgen: local wrapper classes are used to serialize and deserialize multiple parameters.

Version 0.92.1:

- Support for batched ONC/RPC calls when using TCP-based transports: see OncRpcTcpClient.batchCall() for more information.
- Added support for handling multiple ONC/RPC programs and/or versions through the same server transport.
- `jrpcgen` now emits a second constructor expecting the port number to bind transports to as its solely parameter. This allows server writers to bind their servers to well-known ports.
- Added a `jportmap` and an embedded portmap service class. It can be used by standalone applications which should also be useable if the user has not installed a portmap service. I must have been bored or insane. Or both.
- Made several `OncRpcServerStub` methods public (instead of protected), to give derived server classes more control over the way they spin up and down.

Version 0.91.2:

- Ashes on my head for releasing 0.91.1 with a really dumb bug related to JDK 1.1 backwards compatibility which broke JDK2 compatibility completely. When using reflection one can not call the superclass' methods for obvious reasons, so an endless recursion occured in `OncRpcTcpSocket`. So much for almost not testing the release. To fix this stupid design bug the classes `OncRpcTcpSocket` and `OncRpcUdpSocket` were moved to `OncRpcTcpSocketHelper` and `OncRpcUdpSocketHelper`. They now merely support `Socket` and `DatagramSocket` instead of inheriting from them. This avoids the endless reflection method invocation loop, but is still cheaper in terms of method invocation performance than a wrapper class.
- Fixed missing JDK 1.1 compatibility for the server classes.

Version 0.91.1:

- Fixed a deserialization bug with `AUTH_NONE` on the server side in `OncRpcServerAuth.xdrNew` when recycling the `AUTH_NONE` handler singleton.
- Removed automatic startup from the constructor of `jrpcgen` generated server stubs. The constructor of a server stub class now only creates the transport objects and sets the public `transports` field within class `OncRpcServerStub`. Registering with the portmapper as well as dispatching calls is now done within the `run()` method (note: without any parameters). You need to change your code accordingly by inserting a call to `run()`, otherwise the server will not start.

          MyServer myserver = new MyServer();
          myserver.run();

- Preparations for cvs check-in: in order to handle individual Java projects in form of cvs submodules within the toplevel cvs module "`java`", some files were moved. The JBuilder project files have been moved to the `projects/` subdirectory.
- Fixed problem with jrpcgen emitting constants which depend on other constants in wrong order. Constants which are needed by other constant definitions are now emitted first. In case an enumeration element depends on a global constant (or for some reason on another enumeration element), then the enclosure is taken into account too. The `demo.x` example now tests some pathological cases.
- Added backward support for JDK 1.1. While I'm not very proud of it, many people requested this as quite some companies use the bug-ridden MS InternetExploder with its very own JVM. Changes include using `addElement` instead of `add` when adding objects to a `Vector`.
- Moved the readme documentation into its own directory `readme-first/` which should be more obvious to first-time users of the RemoteTea source code and does not clobber the `projects/` directory any more.
- Fixed `NullPointerException` in `OncRpcTcpClient` and `OncRpcUdpClient` when checking for rejected credentials -- and I thought Java had no pointers.
- `jrpcgen`: support for short form `unsigned` in addition to `unsigned int` (compatibility with `rpcgen`). Handling of octal numbers added (okay, it is still a valid number format). Fixed bug in the code generation of desciminated unions using booleans. Support for more than one program definition within the same x-file. In this case the source code files generated for the client and server stubs are named <x-filename><program-id>`Client.java` and <x-filename><program-id>`Server.java`, respectively.
- First rough cut for tunneling ONC/RPC client calls through HTTP connections. On the other end, you will need the "Tea Tunnel" Apache DSO module, which "untunnels" calls and forwards them to the appropriate ONC/RPC server using direct TCP/IP or UDP/IP connections (or non-connections in the case of UDP/IP).
- Added new package `org.acplt.oncrpc.web` containing helper classes for HTTP client connections (`HttpClientConnection`), and base64 encoding and decoding (`Base64`), as well as some other stuff.
- Added new class `OncRpcHttpClient`, which stands in the tradition of `OncRpcClient` and implements sending ONC/RPC calls through HTTP tunnels. Also added `XdrHttpDecodingStream`, which can pull base64 encoded data from a web server and provide the decoded data through the usual decoding XDR stream interface.

Version 0.90.1:

- Fixed `XdrEncodingStream.xdrEncodeByteFixedVector()` which falsely encoded length information about the following array of characters. I should take more care when doing "Italian code recycling" using copy & pasta...
- Fixed bug in `OncRpcTcpClient.call()` which caused XDR buffer underflows when receiving the next reply after the previous reply has been rejected by an ONC/RPC server.
- Updated package.html for package `org.acplt.oncrpc` to put it in sync with (de-) serializing fixed-size vectors and dynamic and fixed vectors of characters.
- Added `AUTH_UNIX` authentication. For this to achieve quite some additions and changes were necessary -- luckily, old applications will not be broken, as the changes are deep within the RemoteTea package:
  - See OncRpcClient for a description about how to use authentication with ONC/RPC clients.
  - For handling of client-side authentication issues, the classes `OncRpcClientAuth`, `OncRpcClientAuthNone` and `OncRpcClientAuthUnix` were added.
  - The ONC/RPC call and reply message classes `OncRpcReplyMessage` and `OncRpcCallMessage` are now both abstract. This was necessary because ONC/RPC protocol issues make it necessary to handle authentication through so-called authentication protocol handling objects different on the client side than on the server side. Additional classes now handle sending calls and receiving replies on the client side (`OncRpcClientCallMessage` and `OncRpcClientReplyMessage` respectively), as well as on the server side (`OncRpcServerCallMessage` and `OncRpcServerReplyMessage`). According to their needs, these new classes only declare those encoding and decoding methods which are really needed. In consequence, the base class `OncRpcCallMessage` has lost its `XdrAble` interface completely.
  - Added authentication handling and credential refreshing to `OncRpcUdpClient` and `OncRpcTcpClient`, as well as to the base class `OncRpcClient`.
  - Added authentication protocol handling to ONC/RPC transports. If servers want to take advantage of authentication, they need to look at the `callMessage.auth` attribute of the `OncRpcCallInformation` delivered with each incomming ONC/RPC call. See `tests.org.acplt.oncrpc.ServerTest.java` for an example.
  Please note that `AUTH_DES` is still not supported, as this needs quite some things to be done and I don't have full information about the `AUTH_DES` protocol.
- Added new classes `XdrBufferEncodingStream` and `XdrBufferDecodingStream` for encoding and decoding XDR data from and to a fixed-size buffer. These classes comes in handy when dealing with shorthand credentials.
- Added class `XdrDynamicOpaque` to handle variable-sized vectors of bytes.
- Moved the jrpcgen package to `org.acplt.oncrpc.apps.jrpcgen`, because it's an application belonging very tight to ONC/RPC.
- Added new `OncRpcConstants.REMOTETEA_VERSION_PREVERSION`, which indicates preversions if not zero.

Version 0.86.1:

- As Sun's rpcgen encodes `char<>` as a series of characters, each one sitting happily in its very own XDR int (that is, four bytes), the two methods `XdrDecodingStream.xdrDecodeBytes()` and `XdrEncodingStream.xdrEncodeBytes()` were renamed to `XdrDecodingStream.xdrDecodeByteVector()` and `XdrEncodingStream.xdrEncodeByteVector()` as well as their semantics changed accordingly.
- Added methods `XdrDecodingStream.xdrDecodeDynamicOpaque()`, `XdrEncodingStream.xdrEncodeDynamicOpaque()`, `XdrDecodingStream.xdrDecodeByteFixedVector()` and `XdrEncodingStream.xdrEncodeByteFixedVector()`.
- Fixed jrpcgen accordingly, so it generates proper code for arrays of bytes and opaque data types accordingly.
- Made all non-abstract encoding and decoding methods in `XdrDecodingStream` and `XdrEncodingStream` finally `final`. Maybe this helps Java compilers improve code speed. Maybe.
- Fixed jrpcgen code generation error when the size of an array was specified using a constant identifier. Now jrpcgen properly references the constant from the x-file's main class.
- Fixed some documentation errors for `XdrDecodingStream` and `XdrEncodingStream`.

Version 0.85.1:

- Added new method `readBuffer()` to class `XdrTcpDecodingStream`. This fixes problems when reading from a TCP/IP stream and not all bytes wanted are immediately available, thus `stream.read()` returning not all bytes at once (shame on me for not reading the java.io documentation attentive enough).

Version 0.84.1:

- Added control over the retransmission strategy used by UDP/IP-based ONC/RPC clients. The default strategy is now not to resend lost ONC/RPC calls (retransmission timeout is set to the overall timeout). Either a fixed retransmission timeout can be choosen, where lost calls are resend every <retransmission timeout> milliseconds, or an exponential back-off alogorithm. The exponential scheme starts with the retransmission timeout and doubles it every time a call is lost, until the overall timeout is reached.
- Added two more constructors to ONC/RPC clients generated by jrpcgen from x-files. These constructors now also accept the remote program number, so application writers gain full control.

Version 0.83.1:

- Fixed support for indirection in decriminated unions. Also cleaned up some minor things related to constants and enumerations. Thanks to Ulrik Sandberg for throwing all kinds of vicious x-files at jrpcgen.

Version 0.82.1:

- Added support for indirection in x-files, also called "optional data" in ONC/RPC babble. Also added a new test case to the demo.x file.

Version 0.81.1:

- Added broadcasting of ONC/RPC calls to UDP/IP-based ONC/RPC clients through the new `broadcastCall` of method in class `OncRpcUdpClient`.
- Added helper methods for encoding and decoding fixed-size vectors for various base data types.
- Added a description about mapping rpcgen (RFC 1832) data types to Java data type.
- Added an RPC protocol compiler named `jrpcgen`. Sun's documentation on the rpcgen syntax and grammar is rather thin and sometimes inaccurate. As always, I had to resort to RTSL ("Read The Source, Luke!") to find out what syntax and grammar rpcgen does in fact use. Please give it a try and report problems. Note that there is no preprocessor step.

Version 0.80.2:

- Fixed a buffer underflow exception in XdrUdpDecodingStream in methods xdrDecodeOpaque(int) and xdrDecodeOpaque(byte[],int,int). This cures the bug where a XDR string being the last piece of information in a RPC call or reply could not be read successfully.
- Added org.acplt.oncrpc.OncRpcConstants, which contains versioning information.

Version 0.80.1:

- Separated the ONC/RPC package under the name "Remote Tea" from the ACPLTea package. As the ONC/RPC implementation is pretty functional the version number was changed to reflect this.
- Added XDR primitive and serializable data types for strings, floats, etc.

Version 0.35.1 and before:

- Graciously hidden in the mist of history (probably also in the midst of history). The Remote Tea package was then only available together with the ACPLTea package but not separate.