* Gets the array of supported authentication mechanisms
     * @return the mechanisms array
     */
    public ASN1ObjectIdentifier[] getMechanisms() {
        return this.mechanisms;
    }

    /**
     * Sets the array of supported authentication mechanisms
     * @param mechanisms the mechanisms to set
     */
    public void setMechanisms(final ASN1ObjectIdentifier[] mechanisms) {
        this.mechanisms = mechanisms;

        @DisplayName("Various mechanism combinations round-trip correctly")
        void testMechanismCombinations(ASN1ObjectIdentifier[] mechanisms) throws Exception {
            NegTokenInit init = new NegTokenInit(mechanisms, 0, null, null);
            byte[] encoded = init.toByteArray();
            NegTokenInit parsed = new NegTokenInit(encoded);

            if (mechanisms == null) {

    /**
     * Checks whether the specified security mechanism is supported.
     * @param mechanism the security mechanism OID to check
     * @return whether the specified mechanism is supported
     */
    boolean isSupported(ASN1ObjectIdentifier mechanism);

    /**
     * Checks whether the specified mechanism is the preferred mechanism.
     * @param selectedMech the selected mechanism OID

///

## Other models { #other-models }

You can now get the current user directly in the *path operation functions* and deal with the security mechanisms at the **Dependency Injection** level, using `Depends`.

And you can use any model or data for the security requirements (in this case, a Pydantic model `User`).

 */

package jcifs.dcerpc;

import jcifs.dcerpc.ndr.NdrBuffer;

/**
 * Interface for providing security services for DCE/RPC communications.
 * This interface abstracts authentication and encryption mechanisms.
 */
public interface DcerpcSecurityProvider {

    /**
     * Wraps outgoing DCERPC message data for security protection
     * @param outgoing the buffer containing data to be wrapped

    CIFSContext tc;

    @Mock
    Configuration config;

    private static byte[] spnegoInitWithMechs(ASN1ObjectIdentifier... mechs) {
        // Build a minimal SPNEGO NegTokenInit containing the provided mechanisms
        NegTokenInit tok = new NegTokenInit(mechs, 0, null, null);
        return tok.toByteArray();
    }

    @Test
    @DisplayName("createContext: rejects NetBIOS/short host names")

 * handled internally to the <code>jcifs.smb</code> package.
 * <p>
 * This class is a wrapper for both {@link jcifs.netbios.NbtAddress}
 * and {@link java.net.InetAddress}. The name resolution mechanisms
 * used will systematically query all available configured resolution
 * services including WINS, broadcasts, DNS, and LMHOSTS. See
 * <a href="../../resolver.html">Setting Name Resolution Properties</a>

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * RDMA error handling and recovery logic.
 *
 * This class provides centralized error handling for RDMA operations,
 * including retry logic and fallback mechanisms.
 */
public class RdmaErrorHandler {

    private static final Logger log = LoggerFactory.getLogger(RdmaErrorHandler.class);

    // Retry and timing constants (in ms)

  -v D:\data:/data \
  quay.io/minio/minio server /data --console-address ":9001"
```

### Run MinIO Docker as a regular user

Docker provides standardized mechanisms to run docker containers as non-root users.

#### GNU/Linux and macOS (regular user)

On Linux and macOS you can use `--user` to run the container as regular user.

///

## **FastAPI** utilities { #fastapi-utilities }

FastAPI provides several tools for each of these security schemes in the `fastapi.security` module that simplify using these security mechanisms.

In the next chapters you will see how to add security to your API using those tools provided by **FastAPI**.