//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.jboss.invocation.http.servlet;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.lang.reflect.Method;
import java.security.Principal;
import java.util.Map;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.jboss.invocation.MarshalledInvocation;
import org.jboss.logging.Logger;
import org.jboss.mx.util.MBeanServerLocator;

public class ReadOnlyAccessFilter implements Filter {
    private static Logger log = Logger.getLogger(ReadOnlyAccessFilter.class);
    private FilterConfig filterConfig = null;
    private String readOnlyContext;
    private Map namingMethodMap;

    public ReadOnlyAccessFilter() {
    }

    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig = filterConfig;
        if (filterConfig != null) {
            this.readOnlyContext = filterConfig.getInitParameter("readOnlyContext");
            String invokerName = filterConfig.getInitParameter("invokerName");

            try {
                MBeanServer mbeanServer = MBeanServerLocator.locateJBoss();
                ObjectName mbean = new ObjectName(invokerName);
                this.namingMethodMap = (Map)mbeanServer.getAttribute(mbean, "MethodMap");
            } catch (Exception var5) {
                log.error("Failed to init ReadOnlyAccessFilter", var5);
                throw new ServletException("Failed to init ReadOnlyAccessFilter", var5);
            }
        }

    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest)request;
        Principal user = httpRequest.getUserPrincipal();
        if (user == null && this.readOnlyContext != null) {
            ServletInputStream sis = request.getInputStream();
            ObjectInputStream ois = new ObjectInputStream(sis);
            MarshalledInvocation mi = null;

            try {
                mi = (MarshalledInvocation)ois.readObject();
            } catch (ClassNotFoundException var10) {
                throw new ServletException("Failed to read MarshalledInvocation", var10);
            }

            request.setAttribute("MarshalledInvocation", mi);
            mi.setMethodMap(this.namingMethodMap);
            Method m = mi.getMethod();
            if (m != null) {
                this.validateAccess(m, mi);
            }
        }

        chain.doFilter(request, response);
    }

    public void destroy() {
    }

    public String toString() {
        if (this.filterConfig == null) {
            return "NamingAccessFilter()";
        } else {
            StringBuffer sb = new StringBuffer("NamingAccessFilter(");
            sb.append(this.filterConfig);
            sb.append(")");
            return sb.toString();
        }
    }

    private void validateAccess(Method m, MarshalledInvocation mi) throws ServletException {
        boolean trace = log.isTraceEnabled();
        if (trace) {
            log.trace("Checking against readOnlyContext: " + this.readOnlyContext);
        }

        String methodName = m.getName();
        if (!methodName.equals("lookup")) {
            throw new ServletException("Only lookups against " + this.readOnlyContext + " are allowed");
        } else {
            Object[] args = mi.getArguments();
            Object arg = args.length > 0 ? args[0] : "";
            String name;
            if (arg instanceof String) {
                name = (String)arg;
            } else {
                name = arg.toString();
            }

            if (trace) {
                log.trace("Checking lookup(" + name + ") against: " + this.readOnlyContext);
            }

            if (!name.startsWith(this.readOnlyContext)) {
                throw new ServletException("Lookup(" + name + ") is not under: " + this.readOnlyContext);
            }
        }
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.jboss.invocation.http.servlet;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.security.AccessController;
import java.security.Principal;
import java.security.PrivilegedAction;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.jboss.invocation.InvocationException;
import org.jboss.invocation.MarshalledInvocation;
import org.jboss.invocation.MarshalledValue;
import org.jboss.logging.Logger;
import org.jboss.mx.util.JMXExceptionDecoder;
import org.jboss.mx.util.MBeanServerLocator;
import org.jboss.security.SecurityAssociation;
import org.jboss.system.Registry;

public class InvokerServlet extends HttpServlet {
    private static Logger log = Logger.getLogger(InvokerServlet.class);
    private static String REQUEST_CONTENT_TYPE = "application/x-java-serialized-object; class=org.jboss.invocation.MarshalledInvocation";
    private static String RESPONSE_CONTENT_TYPE = "application/x-java-serialized-object; class=org.jboss.invocation.MarshalledValue";
    private MBeanServer mbeanServer;
    private ObjectName localInvokerName;

    public InvokerServlet() {
    }

    public void init(ServletConfig config) throws ServletException {
        super.init(config);

        try {
            String name = config.getInitParameter("invokerName");
            if (name != null) {
                this.localInvokerName = new ObjectName(name);
                log.debug("localInvokerName=" + this.localInvokerName);
            }
        } catch (MalformedObjectNameException var3) {
            throw new ServletException("Failed to build invokerName", var3);
        }

        this.mbeanServer = MBeanServerLocator.locateJBoss();
        if (this.mbeanServer == null) {
            throw new ServletException("Failed to locate the MBeanServer");
        }
    }

    public void destroy() {
    }

    protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        boolean trace = log.isTraceEnabled();
        if (trace) {
            log.trace("processRequest, ContentLength: " + request.getContentLength());
            log.trace("processRequest, ContentType: " + request.getContentType());
        }

        Boolean returnValueAsAttribute = (Boolean)request.getAttribute("returnValueAsAttribute");

        try {
            response.setContentType(RESPONSE_CONTENT_TYPE);
            MarshalledInvocation mi = (MarshalledInvocation)request.getAttribute("MarshalledInvocation");
            if (mi == null) {
                ServletInputStream sis = request.getInputStream();
                ObjectInputStream ois = new ObjectInputStream(sis);
                mi = (MarshalledInvocation)ois.readObject();
                ois.close();
            }

            if (mi.getPrincipal() == null && mi.getCredential() == null) {
                mi.setPrincipal(InvokerServlet.GetPrincipalAction.getPrincipal());
                mi.setCredential(InvokerServlet.GetCredentialAction.getCredential());
            }

            Object[] params = new Object[]{mi};
            String[] sig = new String[]{"org.jboss.invocation.Invocation"};
            ObjectName invokerName = this.localInvokerName;
            if (invokerName == null) {
                Integer nameHash = (Integer)mi.getObjectName();
                invokerName = (ObjectName)Registry.lookup(nameHash);
                if (invokerName == null) {
                    throw new ServletException("Failed to find invoker name for hash(" + nameHash + ")");
                }
            }

            Object value = this.mbeanServer.invoke(invokerName, "invoke", params, sig);
            if (returnValueAsAttribute != null && returnValueAsAttribute) {
                request.setAttribute("returnValue", value);
            } else {
                MarshalledValue mv = new MarshalledValue(value);
                ServletOutputStream sos = response.getOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(sos);
                oos.writeObject(mv);
                oos.close();
            }
        } catch (Throwable var13) {
            Throwable t = JMXExceptionDecoder.decode(var13);
            if (t instanceof InvocationTargetException) {
                InvocationTargetException ite = (InvocationTargetException)t;
                t = ite.getTargetException();
            }

            InvocationException appException = new InvocationException(t);
            if (returnValueAsAttribute != null && returnValueAsAttribute) {
                log.debug("Invoke threw exception", t);
                request.setAttribute("returnValue", appException);
            } else if (response.isCommitted()) {
                log.error("Invoke threw exception, and response is already committed", t);
            } else {
                response.resetBuffer();
                MarshalledValue mv = new MarshalledValue(appException);
                ServletOutputStream sos = response.getOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(sos);
                oos.writeObject(mv);
                oos.close();
            }
        }

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.processRequest(request, response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.processRequest(request, response);
    }

    public String getServletInfo() {
        return "An HTTP to JMX invocation servlet";
    }

    private static class GetCredentialAction implements PrivilegedAction {
        static PrivilegedAction ACTION = new InvokerServlet.GetCredentialAction();

        private GetCredentialAction() {
        }

        public Object run() {
            Object credential = SecurityAssociation.getCredential();
            return credential;
        }

        static Object getCredential() {
            Object credential = AccessController.doPrivileged(ACTION);
            return credential;
        }
    }

    private static class GetPrincipalAction implements PrivilegedAction {
        static PrivilegedAction ACTION = new InvokerServlet.GetPrincipalAction();

        private GetPrincipalAction() {
        }

        public Object run() {
            Principal principal = SecurityAssociation.getPrincipal();
            return principal;
        }

        static Principal getPrincipal() {
            Principal principal = (Principal)AccessController.doPrivileged(ACTION);
            return principal;
        }
    }
}