/// <summary> /// Decodes -- that is: deserializes -- an ONC/RPC authentication object /// (credential & verifier) on the server side. /// </summary> /// <remarks> /// Decodes -- that is: deserializes -- an ONC/RPC authentication object /// (credential & 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 xdrDecodeCredVerf(org.acplt.oncrpc.XdrDecodingStream xdr) { // // As the authentication type has already been pulled off the XDR // stream, we only need to make sure that really no opaque data follows. // if (xdr.xdrDecodeInt() != 0) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_BADCRED)); } // // We also need to decode the verifier. This must be 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. // if ((xdr.xdrDecodeInt() != org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE) || ( xdr.xdrDecodeInt() != 0)) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_BADVERF)); } }
/// <summary> /// Decodes -- that is: deserializes -- a ONC/RPC message header object /// from a XDR stream according to RFC 1831. /// </summary> /// <remarks> /// Decodes -- that is: deserializes -- a ONC/RPC message header object /// from a XDR stream according to RFC 1831. /// </remarks> /// <param name="xdr">A decoding XDR stream from which to receive all the mess.</param> /// <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 xdrDecode(org.acplt.oncrpc.XdrDecodingStream xdr) { messageId = xdr.xdrDecodeInt(); // // Make sure that we are really decoding an ONC/RPC message call // header. Otherwise, throw the appropriate OncRpcException exception. // messageType = xdr.xdrDecodeInt(); if (messageType != org.acplt.oncrpc.OncRpcMessageType.ONCRPC_CALL) { throw (new org.acplt.oncrpc.OncRpcException(org.acplt.oncrpc.OncRpcException.RPC_WRONGMESSAGE )); } // // Make sure that the other side is talking the right slang -- // we will only understand version 2 slang of ONC/RPC. // oncRpcVersion = xdr.xdrDecodeInt(); if (oncRpcVersion != ONCRPC_VERSION) { throw (new org.acplt.oncrpc.OncRpcException(org.acplt.oncrpc.OncRpcException.RPC_VERSMISMATCH )); } // // Now decode the remaining fields of the call header. // program = xdr.xdrDecodeInt(); version = xdr.xdrDecodeInt(); procedure = xdr.xdrDecodeInt(); // // Last comes the authentication data. Note that the "factory" hidden // within xdrNew() will graciously recycle any old authentication // protocol handling object if it is of the same authentication type // as the new one just coming in from the XDR wire. // auth = org.acplt.oncrpc.server.OncRpcServerAuth.xdrNew(xdr, auth); }
/// <summary> /// Decodes -- that is: deserializes -- an object from a XDR stream in /// compliance to RFC 1832. /// </summary> /// <remarks> /// Decodes -- that is: deserializes -- an object from 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 xdrDecode(org.acplt.oncrpc.XdrDecodingStream xdr) { // // Make sure that when deserializing this object's state that // the stream provides state information indeed intended for this // particular class. // int xdrTypeCode = xdr.xdrDecodeInt(); if (xdrTypeCode != getXdrTypeCode()) { throw (new System.Exception(this.GetType().Name + "non-matching XDR type code received.")); } // // 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. // xdrDecodeVariant(xdr); xdrDecodeCommon(xdr); }
/// <summary> /// Decodes -- that is: deserializes -- an <code>OncRpcGetPortParams</code> /// object from a XDR stream. /// </summary> /// <remarks> /// Decodes -- that is: deserializes -- an <code>OncRpcGetPortParams</code> /// object from 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 xdrDecode(org.acplt.oncrpc.XdrDecodingStream xdr) { port = xdr.xdrDecodeInt(); }
/// <summary> /// Decodes -- that is: deserializes -- a ONC/RPC message header object /// from a XDR stream. /// </summary> /// <remarks> /// Decodes -- that is: deserializes -- a ONC/RPC message header object /// from 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 xdrDecode(org.acplt.oncrpc.XdrDecodingStream xdr) { messageId = xdr.xdrDecodeInt(); // // Make sure that we are really decoding an ONC/RPC message call // header. Otherwise, throw the appropriate OncRpcException exception. // messageType = xdr.xdrDecodeInt(); if (messageType != org.acplt.oncrpc.OncRpcMessageType.ONCRPC_REPLY) { throw (new org.acplt.oncrpc.OncRpcException(org.acplt.oncrpc.OncRpcException.RPC_WRONGMESSAGE )); } replyStatus = xdr.xdrDecodeInt(); switch (replyStatus) { case org.acplt.oncrpc.OncRpcReplyStatus.ONCRPC_MSG_ACCEPTED: { // // Decode the information returned for accepted message calls. // If we have an associated client-side authentication protocol // object, we use that. Otherwise we fall back to the default // handling of only the AUTH_NONE authentication. // if (auth != null) { auth.xdrDecodeVerf(xdr); } else { // // If we don't have a protocol handler and the server sent its // reply using another authentication scheme than AUTH_NONE, we // will throw an exception. Also we check that no-one is // actually sending opaque information within AUTH_NONE. // if (xdr.xdrDecodeInt() != org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_FAILED)); } if (xdr.xdrDecodeInt() != 0) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_FAILED)); } } // // Even if the call was accepted by the server, it can still // indicate an error. Depending on the status of the accepted // call we will receive an indication about the range of // versions a particular program (server) supports. // acceptStatus = xdr.xdrDecodeInt(); switch (acceptStatus) { case org.acplt.oncrpc.OncRpcAcceptStatus.ONCRPC_PROG_MISMATCH: { lowVersion = xdr.xdrDecodeInt(); highVersion = xdr.xdrDecodeInt(); 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. // rejectStatus = xdr.xdrDecodeInt(); switch (rejectStatus) { case org.acplt.oncrpc.OncRpcRejectStatus.ONCRPC_RPC_MISMATCH: { lowVersion = xdr.xdrDecodeInt(); highVersion = xdr.xdrDecodeInt(); break; } case org.acplt.oncrpc.OncRpcRejectStatus.ONCRPC_AUTH_ERROR: { authStatus = xdr.xdrDecodeInt(); break; } default: { break; } } break; } } }
/// <summary> /// Decodes ONC/RPC authentication information in form of a verifier /// when receiving an ONC/RPC reply message. /// </summary> /// <remarks> /// Decodes ONC/RPC authentication information in form of a verifier /// when receiving an ONC/RPC reply message. /// </remarks> /// <param name="xdr"> /// XDR stream from which to receive the verifier sent together /// with an ONC/RPC reply message. /// </param> /// <exception cref="OncRpcAuthenticationException"> /// if the received verifier is /// not kosher. /// </exception> /// <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 xdrDecodeVerf(org.acplt.oncrpc.XdrDecodingStream xdr) { // // Make sure that we received a AUTH_NONE verifier and that it // does not contain any opaque data. Anything different from this // is not kosher and an authentication exception will be thrown. // if ((xdr.xdrDecodeInt() != org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE) || ( xdr.xdrDecodeInt() != 0)) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_FAILED)); } }
/// <summary>Restores (deserializes) an authentication object from an XDR stream.</summary> /// <remarks>Restores (deserializes) an authentication object from an XDR stream.</remarks> /// <param name="xdr"> /// XDR stream from which the authentication object is /// restored. /// </param> /// <param name="recycle"> /// old authtentication object which is intended to be /// reused in case it is of the same authentication type as the new /// one just arriving from the XDR stream. /// </param> /// <returns> /// Authentication information encapsulated in an object, whose class /// is derived from <code>OncRpcServerAuth</code>. /// </returns> /// <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 static org.acplt.oncrpc.server.OncRpcServerAuth xdrNew(org.acplt.oncrpc.XdrDecodingStream xdr, org.acplt.oncrpc.server.OncRpcServerAuth recycle) { org.acplt.oncrpc.server.OncRpcServerAuth auth; // // In case we got an old authentication object and we are just about // to receive an authentication with the same type, we reuse the old // object. // int authType = xdr.xdrDecodeInt(); if ((recycle != null) && (recycle.getAuthenticationType() == authType)) { // // Simply recycle authentication object and pull its new state // of the XDR stream. // auth = recycle; auth.xdrDecodeCredVerf(xdr); } else { switch (authType) { case org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE: { // // Create a new authentication object and pull its state off // the XDR stream. // auth = org.acplt.oncrpc.server.OncRpcServerAuthNone.AUTH_NONE; auth.xdrDecodeCredVerf(xdr); break; } case org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_SHORT: { auth = new org.acplt.oncrpc.server.OncRpcServerAuthShort(xdr); break; } case org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_UNIX: { auth = new org.acplt.oncrpc.server.OncRpcServerAuthUnix(xdr); break; } default: { // // In case of an unknown or unsupported type, throw an exception. // Note: using AUTH_REJECTEDCRED is in sync with the way Sun's // ONC/RPC implementation does it. But don't ask me why they do // it this way...! // throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_REJECTEDCRED)); } } } return auth; }
/// <summary> /// Decodes -- that is: deserializes -- an OncRpcServerIdent object /// from a XDR stream. /// </summary> /// <remarks> /// Decodes -- that is: deserializes -- an OncRpcServerIdent object /// from 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 xdrDecode(org.acplt.oncrpc.XdrDecodingStream xdr) { program = xdr.xdrDecodeInt(); version = xdr.xdrDecodeInt(); protocol = xdr.xdrDecodeInt(); port = xdr.xdrDecodeInt(); }
/// <summary> /// Decodes -- that is: deserializes -- an ONC/RPC authentication object /// (credential & verifier) on the server side. /// </summary> /// <remarks> /// Decodes -- that is: deserializes -- an ONC/RPC authentication object /// (credential & 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 xdrDecodeCredVerf(org.acplt.oncrpc.XdrDecodingStream xdr) { // // Reset some part of the object's state... // shorthandVerf = null; // // Now pull off the object state of the XDR stream... // int realLen = xdr.xdrDecodeInt(); stamp = xdr.xdrDecodeInt(); machinename = xdr.xdrDecodeString(); uid = xdr.xdrDecodeInt(); gid = xdr.xdrDecodeInt(); gids = xdr.xdrDecodeIntVector(); // // Make sure that the indicated length of the opaque data is kosher. // If not, throw an exception, as there is something strange going on! // 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 (realLen != len) { if (realLen < len) { throw (new org.acplt.oncrpc.OncRpcException(org.acplt.oncrpc.OncRpcException.RPC_BUFFERUNDERFLOW )); } else { throw (new org.acplt.oncrpc.OncRpcException(org.acplt.oncrpc.OncRpcException.RPC_AUTHERROR )); } } // // We also need to decode the verifier. This must be 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. // if ((xdr.xdrDecodeInt() != org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE) || ( xdr.xdrDecodeInt() != 0)) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_BADVERF)); } }
/// <summary> /// Decodes -- that is: deserializes -- an ONC/RPC authentication object /// (credential & verifier) on the server side. /// </summary> /// <remarks> /// Decodes -- that is: deserializes -- an ONC/RPC authentication object /// (credential & 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 xdrDecodeCredVerf(org.acplt.oncrpc.XdrDecodingStream xdr) { // // Reset the authentication object's state properly... // shorthandCred = null; shorthandVerf = null; // // Pull off the shorthand credential information (opaque date) of // the XDR stream... // shorthandCred = xdr.xdrDecodeDynamicOpaque(); if (shorthandCred.Length > org.acplt.oncrpc.OncRpcAuthConstants.ONCRPC_MAX_AUTH_BYTES) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_BADCRED)); } // // We also need to decode the verifier. This must be 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. // if ((xdr.xdrDecodeInt() != org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE) || ( xdr.xdrDecodeInt() != 0)) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_BADVERF)); } }
/// <summary> /// Decodes ONC/RPC authentication information in form of a verifier /// when receiving an ONC/RPC reply message. /// </summary> /// <remarks> /// Decodes ONC/RPC authentication information in form of a verifier /// when receiving an ONC/RPC reply message. /// </remarks> /// <param name="xdr"> /// XDR stream from which to receive the verifier sent together /// with an ONC/RPC reply message. /// </param> /// <exception cref="OncRpcAuthenticationException"> /// if the received verifier is /// not kosher. /// </exception> /// <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 xdrDecodeVerf(org.acplt.oncrpc.XdrDecodingStream xdr) { switch (xdr.xdrDecodeInt()) { case org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_NONE: { // // The verifier sent in response to AUTH_UNIX or AUTH_SHORT credentials // can only be AUTH_NONE or AUTH_SHORT. In the latter case we drop // any old shorthand credential and use the new one. // // // Make sure that the verifier does not contain any opaque data. // Anything different from this is not kosher and an authentication // exception will be thrown. // if (xdr.xdrDecodeInt() != 0) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_FAILED)); } break; } case org.acplt.oncrpc.OncRpcAuthType.ONCRPC_AUTH_SHORT: { // // Fetch the credential from the XDR stream and make sure that // it does conform to the length restriction as set forth in // the ONC/RPC protocol. // shorthandCred = xdr.xdrDecodeDynamicOpaque(); if (shorthandCred.Length > org.acplt.oncrpc.OncRpcAuthConstants.ONCRPC_MAX_AUTH_BYTES) { throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_FAILED)); } break; } default: { // // Do not accept any other kind of verifier sent. // throw (new org.acplt.oncrpc.OncRpcAuthenticationException(org.acplt.oncrpc.OncRpcAuthStatus .ONCRPC_AUTH_INVALIDRESP)); } } }