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 2²⁷.
• 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.