C# org.xdrEncodeInt方法代码示例

		/// <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);
 }