/// <summary>
/// Encodes ONC/RPC authentication information in form of a credential
/// and a verifier when sending an ONC/RPC call message.
/// </summary>
/// <remarks>
/// Encodes ONC/RPC authentication information in form of a credential
/// and a verifier when sending an ONC/RPC call message.
/// </remarks>
/// <param name="xdr">
/// XDR stream where to encode the credential and the verifier
/// to.
/// </param>
/// <exception cref="OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="System.IO.IOException">if an I/O error occurs.</exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
internal override void xdrEncodeCredVerf(org.acplt.oncrpc.XdrEncodingStream xdr)
{
//
// The credential only consists of the indication of AUTH_NONE with
// no opaque authentication data following.
//
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE);
xdr.xdrEncodeInt(0);
//
// But we also need to encode the verifier. This is always of type
// AUTH_NONE too. For some obscure historical reasons, we have to
// deal with credentials and verifiers, although they belong together,
// according to Sun's specification.
//
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE);
xdr.xdrEncodeInt(0);
}
/// <summary>
/// Encodes -- that is: serializes -- a ONC/RPC message header object
/// into a XDR stream according to RFC 1831.
/// </summary>
/// <remarks>
/// Encodes -- that is: serializes -- a ONC/RPC message header object
/// into a XDR stream according to RFC 1831.
/// </remarks>
/// <param name="xdr">An encoding XDR stream where to put the mess in.</param>
/// <exception cref="OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="System.IO.IOException">if an I/O error occurs.</exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
public virtual void xdrEncode(org.acplt.oncrpc.XdrEncodingStream xdr)
{
xdr.xdrEncodeInt(messageId);
xdr.xdrEncodeInt(messageType);
xdr.xdrEncodeInt(oncRpcVersion);
xdr.xdrEncodeInt(program);
xdr.xdrEncodeInt(version);
xdr.xdrEncodeInt(procedure);
//
// Now encode the authentication data. If we have an authentication
// protocol handling object at hand, then we let do the dirty work
// for us. Otherwise, we fall back to AUTH_NONE handling.
//
if (auth != null)
{
auth.xdrEncodeCredVerf(xdr);
}
else
{
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE);
xdr.xdrEncodeInt(0);
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE);
xdr.xdrEncodeInt(0);
}
}
/// <summary>
/// Encodes -- that is: serializes -- an object into a XDR stream in
/// compliance to RFC 1832.
/// </summary>
/// <remarks>
/// Encodes -- that is: serializes -- an object into a XDR stream in
/// compliance to RFC 1832.
/// </remarks>
/// <exception cref="OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="System.IO.IOException">if an I/O error occurs.</exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
public virtual void xdrEncode(org.acplt.oncrpc.XdrEncodingStream xdr)
{
//
// For historial reasons (read: "for dumb and pure idiotic reasons")
// and compatibility with the ACPLT/KS C++ Communication Library we
// encode/decode the variant part *first* before encoding/decoding
// the common part.
//
xdr.xdrEncodeInt(getXdrTypeCode());
xdrEncodeVariant(xdr);
xdrEncodeCommon(xdr);
}
/// <summary>
/// Encodes -- that is: serializes -- an <code>OncRpcGetPortParams</code>
/// object into a XDR stream.
/// </summary>
/// <remarks>
/// Encodes -- that is: serializes -- an <code>OncRpcGetPortParams</code>
/// object into a XDR stream.
/// </remarks>
/// <exception cref="OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="System.IO.IOException">if an I/O error occurs.</exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
public virtual void xdrEncode(org.acplt.oncrpc.XdrEncodingStream xdr)
{
xdr.xdrEncodeInt(port);
}
/// <summary>
/// Encodes -- that is: serializes -- a ONC/RPC reply header object
/// into a XDR stream.
/// </summary>
/// <remarks>
/// Encodes -- that is: serializes -- a ONC/RPC reply header object
/// into a XDR stream.
/// </remarks>
/// <exception cref="org.acplt.oncrpc.OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="System.IO.IOException">if an I/O error occurs.</exception>
public virtual void xdrEncode(org.acplt.oncrpc.XdrEncodingStream xdr)
{
xdr.xdrEncodeInt(messageId);
xdr.xdrEncodeInt(messageType);
xdr.xdrEncodeInt(replyStatus);
switch (replyStatus)
{
case org.acplt.oncrpc.OncRpcReplyStatus.ONCRPC_MSG_ACCEPTED:
{
//
// Encode the information returned for accepted message calls.
//
// First encode the authentification data. If someone has
// nulled (nuked?) the authentication protocol handling object
// from the call information object, then we can still fall back
// to sending AUTH_NONE replies...
//
if (auth != null)
{
auth.xdrEncodeVerf(xdr);
}
else
{
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE);
xdr.xdrEncodeInt(0);
}
//
// Even if the call was accepted by the server, it can still
// indicate an error. Depending on the status of the accepted
// call we have to send back an indication about the range of
// versions we support of a particular program (server).
//
xdr.xdrEncodeInt(acceptStatus);
switch (acceptStatus)
{
case org.acplt.oncrpc.OncRpcAcceptStatus.ONCRPC_PROG_MISMATCH:
{
xdr.xdrEncodeInt(lowVersion);
xdr.xdrEncodeInt(highVersion);
break;
}
default:
{
//
// Otherwise "open ended set of problem", like the author
// of Sun's ONC/RPC source once wrote...
//
break;
}
}
break;
}
case org.acplt.oncrpc.OncRpcReplyStatus.ONCRPC_MSG_DENIED:
{
//
// Encode the information returned for denied message calls.
//
xdr.xdrEncodeInt(rejectStatus);
switch (rejectStatus)
{
case org.acplt.oncrpc.OncRpcRejectStatus.ONCRPC_RPC_MISMATCH:
{
xdr.xdrEncodeInt(lowVersion);
xdr.xdrEncodeInt(highVersion);
break;
}
case org.acplt.oncrpc.OncRpcRejectStatus.ONCRPC_AUTH_ERROR:
{
xdr.xdrEncodeInt(authStatus);
break;
}
default:
{
break;
}
}
break;
}
}
}
/// <summary>
/// Encodes -- that is: serializes -- an OncRpcServerIdent object
/// into a XDR stream.
/// </summary>
/// <remarks>
/// Encodes -- that is: serializes -- an OncRpcServerIdent object
/// into a XDR stream.
/// </remarks>
/// <exception cref="OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="System.IO.IOException">if an I/O error occurs.</exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
public virtual void xdrEncode(org.acplt.oncrpc.XdrEncodingStream xdr)
{
xdr.xdrEncodeInt(program);
xdr.xdrEncodeInt(version);
xdr.xdrEncodeInt(protocol);
xdr.xdrEncodeInt(port);
}
/// <summary>
/// Encodes -- that is: serializes -- an ONC/RPC authentication object
/// (its verifier) on the server side.
/// </summary>
/// <remarks>
/// Encodes -- that is: serializes -- an ONC/RPC authentication object
/// (its verifier) on the server side.
/// </remarks>
/// <exception cref="org.acplt.oncrpc.OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="System.IO.IOException">if an I/O error occurs.</exception>
public sealed override void xdrEncodeVerf(org.acplt.oncrpc.XdrEncodingStream xdr)
{
if (shorthandVerf != null)
{
//
// Encode AUTH_SHORT shorthand verifier (credential).
//
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_SHORT);
xdr.xdrEncodeDynamicOpaque(shorthandVerf);
}
else
{
//
// Encode an AUTH_NONE verifier with zero length, if no shorthand
// verifier (credential) has been supplied by now.
//
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE);
xdr.xdrEncodeInt(0);
}
}
/// <summary>
/// Encodes -- that is: serializes -- an ONC/RPC authentication object
/// (its verifier) on the server side.
/// </summary>
/// <remarks>
/// Encodes -- that is: serializes -- an ONC/RPC authentication object
/// (its verifier) on the server side.
/// </remarks>
/// <exception cref="org.acplt.oncrpc.OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="System.IO.IOException">if an I/O error occurs.</exception>
public override sealed void xdrEncodeVerf(org.acplt.oncrpc.XdrEncodingStream xdr)
{
//
// Encode an AUTH_NONE verifier with zero length.
//
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE);
xdr.xdrEncodeInt(0);
}
/// <summary>
/// Encodes ONC/RPC authentication information in form of a credential
/// and a verifier when sending an ONC/RPC call message.
/// </summary>
/// <remarks>
/// Encodes ONC/RPC authentication information in form of a credential
/// and a verifier when sending an ONC/RPC call message. The
/// <code>AUTH_UNIX</code> authentication method only uses the credential
/// but no verifier. If the ONC/RPC server sent a <code>AUTH_SHORT</code>
/// "shorthand" credential together with the previous reply message, it
/// is used instead of the original credential.
/// </remarks>
/// <param name="xdr">
/// XDR stream where to encode the credential and the verifier
/// to.
/// </param>
/// <exception cref="OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="System.IO.IOException">if an I/O error occurs.</exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
internal override void xdrEncodeCredVerf(org.acplt.oncrpc.XdrEncodingStream xdr)
{
if (shorthandCred == null)
{
//
// Encode the credential, which contains some unsecure information
// about user and group ID, etc. Note that the credential itself
// is encoded as a variable-sized bunch of octets.
//
if ((gids.Length > org.acplt.oncrpc.OncRpcAuthConstants.ONCRPC_MAX_GROUPS) || (machinename
.Length > org.acplt.oncrpc.OncRpcAuthConstants.ONCRPC_MAX_MACHINE_NAME))
{
throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus
.ONCRPC_AUTH_FAILED));
}
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_UNIX);
int len = 4 + ((machinename.Length + 7) & ~3) + 4 + 4 + gids.Length * 4 + 4;
// length of stamp
// len string incl. len
// length of uid
// length of gid
// length of vector of gids incl. len
if (len > org.acplt.oncrpc.OncRpcAuthConstants.ONCRPC_MAX_AUTH_BYTES)
{
throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus
.ONCRPC_AUTH_FAILED));
}
xdr.xdrEncodeInt(len);
xdr.xdrEncodeInt(stamp);
xdr.xdrEncodeString(machinename);
xdr.xdrEncodeInt(uid);
xdr.xdrEncodeInt(gid);
xdr.xdrEncodeIntVector(gids);
}
else
{
//
// Use shorthand credential instead of original credential.
//
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_SHORT);
xdr.xdrEncodeDynamicOpaque(shorthandCred);
}
//
// We also need to encode the verifier, which is always of
// type AUTH_NONE.
//
xdr.xdrEncodeInt(org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE);
xdr.xdrEncodeInt(0);
}