Change Log of the Remote Tea Package
Author: Harald Albrecht

# Change Log Remote Tea

Remote Tea Project Home Page on SourceForge.

## Version 1.1.6:

This is a minor maintenance release

### Fixed issues

#### oncrpc, jrpcgen

- Accpted the merge request Remove usage of deprecated JDK API. The merge replaced deprecated boxed primitive constructors with their replacements with respect to [JEP 390] Deprecate wrapper class constructors for removal.

## Version 1.1.5:

This is a minor feature and maintenance release

### New features

#### oncrpc

- The ONC/RPC library has been extended by introducing the use of Java enumerations in favour of Java interfaces for mapping enumerations specified in XDR and RPC specifications, respectively.
- The new class `org.acplt.oncrpc.XdrHashCode` introcudes a common hash method for implementations of the interface `org.acplt.oncrpc.XdrAble`. Disguised as an XDR encoding stream, the hash code of an object is calculated by passing an XDR encoding run (which in turn visits and therefore considers each field of such an object).

#### jrpcgen

- In previous releases, enumerations used to be mapped by Java interfaces. Starting with this release, they are mapped by Java enumerations, which becomes the default mapping for enumerations. Backwards compatibility is given, when passing the flag `-noEnum` to jrpcgen.
- Generating at least either a client or a server stub includes generating a program interface reflecting the program specification given in the x-file.
- Comments starting with `/**` in an x-file are considered as Java documentation and are passed to the generated Java sources.
- By default generated classes for structures and unions get an additional constructor, the so called value constructor. This enables initialization of a new object at construction time. Generation of value constructors can be deactivated by passing the flag `-noValueCtor` to jrpcgen.
- By default generated classes for any type except for Java enumerations get a `toString()` - method, building a string consisting of the name / value pairs of the object fields. The generation of the `toString()` - methods can be deactivated by passing the flag `-noToString` to jrpcgen.
- By default generated classes for any type except for Java enumerations get an `equals()` - and a `hashCode()` - method. The generation of the `equals()` - and the `hashCode()` - method can be deactivated by passing the flag `-noEquals` to jrpcgen.

### Fixed issues

#### jrpcgen

- Declared indirections in an x-file, for example `int *optionalID`, whose types are mapped to Java primitives like `int` and `boolean` used to be declared as usual fields in the generated Java code (`int optionalID` for the given example). Accordingly, the generated coding methods of such fields missed the optional character given in the specification of the x-file. Starting with this release, optional data mapped to Java primitives is generated with their wrapper classes like `java.lang.Integer` instead of `int` and `java.lang.Boolean` instead of `boolean`. Using an object instead of the primitive gives the corresponding fields the optional character and eases the coding of these fields as optional data.

## Version 1.1.4:

This is a minor maintenance release

### Fixed issues

- Reported issue Remove bundled libraries: The JrpcgenSHA (org.acplt.oncrpc.apps.jrpcgen.JrpcgenSHA) interface was based on a bundled implementation of the SHA-1 algorithm introduced by the GNU classpath (gnu.java.security.provider.SHA.java). The change proposed in the reported issue has been patched into this release.
- Reported issue Incorrect Free Software Foundation address: The address of the GNU Free Software Foundation has been changed from 675 Mass Ave, Cambridge, MA 02139, USA to 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

### Miscellaneous

- The test classes have been moved to the test source paths of the corresponding modules.
- A small bug returning false to the first custom authentication scheme registered to a server stub has been fixed.

## Version 1.1.3:

This is a minor maintenance release

### Changed packaging of the ONC/RPC runtime package

The OSGi package bundle of the ONC/RPC runtime library now exports all of the ONC/RPC runtime packages.

## Version 1.1.2:

This is a minor maintenance release

### Changed packaging of the ONC/RPC runtime package

The Maven packaging of the ONC/RPC runtime package has been changed to bundle, adding OSGi bundle information to the manifest.

## Version 1.1.1:

This is a minor maintenance release.

### Reorganization of the project

The project has been converted into a Maven project. It has become a multi-module project, containing the modules oncrpc, jrpcgen, jportmap, maven-plugin and information. The transition into a Maven project intends on:

- separating the project into its modules.
- deploying it to Maven central.
- introducing a Maven plugin for generating Java sources out of an x-file within the Maven life cycle phase generate-sources.

However, the Ant-Build of Remote Tea is still supported and will at least get in charge to create the release zip files, which will be continued to be uploaded to SourceForge.

## Version 1.1.0:

This is a minor feature/maintenance release.

### New features

#### Client-side

- The ONC/RPC client stub implementation has been extended by the method `nullproc()` as a convenient way to launch null procedure calls.
- The instance of an ONC/RPC client stub implementation can now be bound to other ONC/RPC client instances during its lifetime via the method `setClient()`. Besides, a previously used ONC/RPC client instance will be closed by this method.

#### Server-side

- With this release custom authentication schemes can be defined and registered to an ONC/RPC server stub.

#### jrpcgen

- jrpcgen considers and realizes the following new command line options on invocation:

  -t | create TCP server only
  -u | create UDP server only
  -noxdr | do not create XDR datatype classes

### Maintenance

#### Server-side

- Authentication failures such as bad credentials and bad verifier within ONC/RPC authentication handling have not been reported back to clients, properly. Such authentication failures lead now to an appropriate authentication failure reply to clients.

#### jrpcgen

- Consider the following quite legal definitions in an .x-file:

      struct MyStructure {
        int x;
        int y;
      };

      typedef struct MyStructure MyStructure;

  The `typedef` caused an error recognizing a duplicate identifier. Such a `typedef` is now recognized and silently ignored.
  Keep in mind that a typedef such as

      typedef struct MyStructure TMyStructure;

  still leads to the generation of the java class:

      class TMyStructure {

      	public MyStructure value;

      ...
      }

## Version 1.0.7:

You already guessed it: minor update/maintenance release.

- Fixed inheriting character encoding from TCP-based listening server transport to the child TCP-based server connection transports.
- Fixed/corrected behavior when registering server transports: an ONC/RPC exception with the reason `OncRpcException.RPC_CANNOTREGISTER` will now be thrown if the local portmapper denies port registration.

## Version 1.0.6:

This is again a minor update/maintenance release.

- Fixed encapsulation of properties when generating beans.
- Fixed miscalculation of remaining timeout, which could case infinite timeouts.

## Version 1.0.5:

This is a minor update/maintenance release.

- Fixed a code generation error in jrpcgen which cause the protocol compiler to emit ONC/RPC server code that did not properly returned errors for unsupported programs.
- Added new jrpcgen-test target to Ant build file so that the jrpcgen protocol compiler can be more easily tested on the example files.
- Fixed `build.xml` Ant script to include also exactly this build file in the source code zip which gets uploaded to Source Forge.

## Version 1.0.4:

It has been a long time since the previous release ... but yes, I finally managed to pick up the patches sent and rolled them into the new release. Many things changed in the meantime so I'm glad I got this release out of the door at all. My new employer throws all kind of really interesting tasks at me, so RemoteTea is now a really low profile project to me. If volunteers will step forward to maintain RemoteTea I would be glad to welcome them aboard the RemoteTea project.

- Added a new option `-bean` to `jrpcgen` for generating accessors (setters and getters) for all elements in a structure. Option `-bean` also implies `-ser`. This feature bases on a patch from Ralph Neff.
- `jrpcgen` now also accepts .x files without a program section. In this case no stub classes are generated, but Java source code files for all structures, enums, et cetera are still generated. This feature bases on a patch from Bialas Krzysztof.
- Updated to new CPU runtime, see also the CUP LALR Parser Generator in Java Version 11 at TU Munich.
- Incorporated patches for: compile target in Ant build file, include Ant task in `jrpcgen.jar`.
- Thank you all who sent in patches!

## Version 1.0.3:

This release marks my movement from the website of the good old Chair of Process Control Engineering to Sourceforge. Since Remote Tea has now quite some users, it was time to put the project on its own feet. Let's see where this will lead to.

- With my transition from JBuilder to Eclipse a little bit of rearrangement of a few files was necessary. In particular, the old JBuilder project files are gone down the bit bucket, so say hello to the new Eclipse project files. With the switch to Eclipse we now have a free IDE for a free ONC/RPC package – and if you use ClassPath and an appropriate VM, then the whole thing is free.
- Updated documentation – but you will probably already have noticed that from the new style of this and the other HTML files.
- Yet another small correction to jrpcgen: it does not emit unnecessary import statements anymore. This silences especially the Eclipse IDE, but also other smart asses.
- It is now possible to optionally control the character encoding used when (de-)serializing strings. The `OncRpcClient` class now has a pair of accessors `setCharacterEncoding(encoding)` and `getCharacterEncoding()`. Similiar, `OncRpcServerStub` gives control over character encoding on the server side.

## Version 1.0.2:

- Fixed a bug in jrpcgen, which caused the automatically generated constructor in server stubs, which accepts a port number, to ignore this port number.
- Also squashed a bug which caused problems when definitions from enumerations where used as program numbers.
- Small todo work done, so that jrpcgen now emits more useful information in the javadoc tags for remote procedure parameters and results.
- Removed old and useless code from jrpcgen that has alread been commented out for quite some time.
- Added new parameter -withcallinfo to jrpcgen. When specified on the command line, jrpcgen emits server method stubs which contain always as their first parameter an additional parameter holding information about the remote call itself. This can be used, for instance, for authentication purposes, et cetera. The parameter is always named `call$` and of type `OncRpcCallInformation`.
- Added new parameter -noclamp to jrpcgen. When -noclamp is specified on the command line, jrpcgen emits client method stubs which use the version number specified when creating the client object at runtime. When this option is not given, jrpcgen defaults to the current behavior and uses the version number as specified in the x-file.

## 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 static `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 `Jrpcgen.SHA.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.