## Use `CORSMiddleware` { #use-corsmiddleware }

You can configure it in your **FastAPI** application using the `CORSMiddleware`.

* Import `CORSMiddleware`.
* Create a list of allowed origins (as strings).
* Add it as a "middleware" to your **FastAPI** application.

You can also specify whether your backend allows:

            assertTrue(e.getMessage().contains("not allowed"));
        }

        // Should allow other paths
        String allowed = validator.validatePath("\\share\\allowed\\file.txt");
        assertEquals("\\share\\allowed\\file.txt", allowed);
    }

    @Test
    public void testWhitelist() throws Exception {
        validator.addToWhitelist("\\share\\allowed");

        // Should allow whitelisted path

            return userAgent;
        }

        /**
         * Checks if the given path is allowed according to this directive.
         * @param path the path to check
         * @return true if the path is allowed, false otherwise
         */
        public boolean allows(final String path) {
            for (final String allowedPath : allowedPaths) {
                if (path.startsWith(allowedPath)) {

        // Normal authentication should be allowed
        assertTrue(rateLimiter.checkAttempt("user1", "192.168.1.1"), "First attempt should be allowed");

        // Record success
        rateLimiter.recordSuccess("user1", "192.168.1.1");

        // Should still be allowed
        assertTrue(rateLimiter.checkAttempt("user1", "192.168.1.1"), "After success should be allowed");
    }

    @Test

	if s3Err != ErrNone {
		return cred, s3Err
	}
	if globalIAMSys.IsAllowed(policy.Args{
		AccountName:     cred.AccessKey,
		Groups:          cred.Groups,
		Action:          policy.Action(action),
		ConditionValues: getConditionValues(r, "", cred),
		IsOwner:         owner,
		Claims:          cred.Claims,
	}) {
		// Request is allowed return the appropriate access key.
		return cred, ErrNone
	}

    }

    /**
     * CORS header for specifying allowed origin.
     */
    protected static final String ACCESS_CONTROL_ALLOW_ORIGIN = "Access-Control-Allow-Origin";

    /**
     * CORS header for specifying allowed headers.
     */
    protected static final String ACCESS_CONTROL_ALLOW_HEADERS = "Access-Control-Allow-Headers";

    /**
     * CORS header for specifying allowed HTTP methods.
     */

        validator.validatePath("\\share\\folder\\file.txt");
        validator.validatePath("C:\\Windows\\System32");
        validator.validatePath(null); // Null should be allowed
        validator.validatePath(""); // Empty should be allowed
    }

    @Test
    public void testPathTooLong() throws Exception {
        String longPath = "\\share" + "\\folder".repeat(5000);
        assertThrows(SmbException.class, () -> {

        }
        return true;
    }

    /**
     * Checks if the given value matches any of the specified protocols.
     *
     * @param protocols the allowed protocols
     * @param value the URI string to validate
     * @return true if the value matches allowed protocols, false otherwise
     */
    protected static boolean check(final String[] protocols, final String value) {
        final String[] paths = value.split("[\r\n]");

     * standard CORS headers based on application configuration.
     */
    public DefaultCorsHandler() {
        super();
    }

    /**
     * Registers this CORS handler with the factory for configured allowed origins.
     * This method is automatically called after bean initialization.
     */
    @PostConstruct
    public void register() {
        final CorsHandlerFactory factory = ComponentUtil.getCorsHandlerFactory();

    /** Cache file size threshold in bytes */
    private int cacheFileSize = 1_000_000;

    /** Name of the extractor to use */
    private String extractorName = "tikaExtractor";

    /** Maximum content length allowed */
    private long maxContentLength = -1;

    /**
     * Constructs a new ExtractorBuilder.
     *
     * @param crawlerContainer the crawler container
     * @param in the input stream to extract data from