* Provides common CORS header constants and defines the processing interface.
 */
public abstract class CorsHandler {

    /**
     * Creates a new instance of CorsHandler.
     */
    public CorsHandler() {
        // Default constructor
    }

    /**
     * CORS header for specifying allowed origin.
     */

     */
    protected Map<String, CorsHandler> handerMap = new HashMap<>();

    /**
     * Adds a CORS handler for the specified origin.
     *
     * @param origin the origin pattern (can be "*" for wildcard)
     * @param handler the CORS handler to associate with the origin
     */
    public void add(final String origin, final CorsHandler handler) {
        if (logger.isDebugEnabled()) {

        // Execute
        CorsHandler result = corsHandlerFactory.get("");

        // Verify - should return wildcard handler
        assertEquals(wildcardHandler, result);
    }

    public void test_add_nullHandler() {
        // Setup
        String origin = "https://example.com";

        // Execute
        corsHandlerFactory.add(origin, null);
        CorsHandler result = corsHandlerFactory.get(origin);

        private String lastOrigin = null;
        private CorsHandler handler = null;

        @Override
        public CorsHandler get(String origin) {
            getCalled = true;
            lastOrigin = origin;
            return handler;
        }

        public void setHandler(CorsHandler handler) {
            this.handler = handler;
        }

        assertEquals("Access-Control-Allow-Origin", CorsHandler.ACCESS_CONTROL_ALLOW_ORIGIN);
        assertEquals("Access-Control-Allow-Headers", CorsHandler.ACCESS_CONTROL_ALLOW_HEADERS);
        assertEquals("Access-Control-Allow-Methods", CorsHandler.ACCESS_CONTROL_ALLOW_METHODS);
        assertEquals("Access-Control-Allow-Private-Network", CorsHandler.ACCESS_CONTROL_ALLOW_PRIVATE_NETWORK);

package org.codelibs.fess.filter;

import java.io.IOException;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.fess.cors.CorsHandler;
import org.codelibs.fess.cors.CorsHandlerFactory;
import org.codelibs.fess.util.ComponentUtil;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;

 * This handler automatically registers itself for origins configured in the system
 * and applies standard CORS headers based on the application configuration.
 */
public class DefaultCorsHandler extends CorsHandler {

    /**
     * Creates a new instance of DefaultCorsHandler.
     * This constructor initializes the default CORS handler for applying
     * standard CORS headers based on application configuration.
     */

	apiRouter.MethodNotAllowedHandler = collectAPIStats("methodnotallowed", httpTraceAll(methodNotAllowedHandler("S3")))
}

// corsHandler handler for CORS (Cross Origin Resource Sharing)
func corsHandler(handler http.Handler) http.Handler {
	commonS3Headers := []string{
		xhttp.Date,
		xhttp.ETag,
		xhttp.ServerInfo,
		xhttp.Connection,
		xhttp.AcceptRanges,

		}
		// Allow grid to start after registering all services.
		close(globalGridStart)
		close(globalLockGridStart)

		httpServer := xhttp.NewServer(getServerListenAddrs()).
			UseHandler(setCriticalErrorHandler(corsHandler(handler))).
			UseTLSConfig(newTLSConfig(getCert)).
			UseIdleTimeout(globalServerCtxt.IdleTimeout).
			UseReadTimeout(globalServerCtxt.IdleTimeout).
			UseWriteTimeout(globalServerCtxt.IdleTimeout).

	if err != nil {
		t.Fatalf("Failed to configure one of the RPC services <ERROR> %s", err)
	}

	// Run TestServer.
	testServer.Server = httptest.NewUnstartedServer(setCriticalErrorHandler(corsHandler(httpHandler)))

	globalObjLayerMutex.Lock()
	globalObjectAPI = objLayer
	globalObjLayerMutex.Unlock()

	// initialize peer rpc
	host, port := mustSplitHostPort(testServer.Server.Listener.Addr().String())