public String[] getMechanismNames(final Map<String, ?> props) { return delegate.getMechanismNames(props); }
@Override public SaslServer createSaslServer(final String mechanism, final String protocol, final String serverName, final Map<String, ?> props, final CallbackHandler cbh) throws SaslException { for (SaslServerFactory factory : factories) { if (factory != null) { final SaslServer saslServer = factory.createSaslServer(mechanism, protocol, serverName, props, cbh); if (saslServer != null) { return saslServer; } } } return null; }
@Override public String[] getMechanismNames(final Map<String, ?> props) { final LinkedHashSet<String> names = new LinkedHashSet<String>(); for (SaslServerFactory factory : factories) { if (factory != null) { Collections.addAll(names, factory.getMechanismNames(props)); } } return names.toArray(new String[names.size()]); } }
@Override public SaslServer run() throws SaslException { return saslFactory.createSaslServer(mechanism, protocol, serverId, saslProperties, callback); } });
public String[] getMechanismNames(final Map<String, ?> props) { final String[] names = delegate.getMechanismNames(props); final ArrayList<String> list = new ArrayList<>(names.length); for (String name : names) { if (predicate.test(name)) { list.add(name); } } return list.toArray(new String[list.size()]); } }
public SaslServer createSaslServer(final String mechanism, final String protocol, final String serverName, final Map<String, ?> props, final CallbackHandler cbh) throws SaslException { return delegate.createSaslServer(mechanism, protocol, serverName, props, cbh); }
Collection<String> getAllSupportedMechNames() { final String[] names = saslServerFactory.getMechanismNames(Collections.singletonMap(WildFlySasl.MECHANISM_QUERY_ALL, "true")); // todo: filter down based on SASL selection criteria if (names == null || names.length == 0) { return Collections.emptyList(); } else if (names.length == 1) { return Collections.singletonList(names[0]); } else { return Arrays.asList(names); } }
public SaslServer createSaslServer(final String mechanism, final String protocol, final String serverName, final Map<String, ?> props, final CallbackHandler cbh) throws SaslException { final SaslServer saslServer = delegate.createSaslServer(mechanism, protocol, serverName, props, cbh); return saslServer == null ? null : new AbstractDelegatingSaslServer(saslServer) { public void dispose() throws SaslException { try { super.dispose(); } finally { try { cbh.handle(new Callback[] { SecurityLayerDisposedCallback.getInstance() }); } catch (Throwable ignored) { } } } }; } }
@Override public String[] getMechanismNames(Map<String, ?> props) { return delegate.getMechanismNames(combine(props, properties)); }
public SaslServerContext(final SaslServerFactory saslServerFactory, final String mech, final String serverName, final CallbackHandler callback_handler, final Map<String, String> props, final Subject subject) throws SaslException { this.subject = subject; if (this.subject != null) { try { server = Subject.doAs(this.subject, (PrivilegedExceptionAction<SaslServer>)() -> saslServerFactory.createSaslServer(mech, SASL.SASL_PROTOCOL_NAME, serverName, props, callback_handler)); } catch (PrivilegedActionException e) { throw (SaslException)e.getCause(); // The createSaslServer will only throw this type of exception } } else { server = saslServerFactory.createSaslServer(mech, SASL.SASL_PROTOCOL_NAME, serverName, props, callback_handler); } }
public static SaslServerFactory getSaslServerFactory(String mech, Map<String, ?> props) { Iterator<SaslServerFactory> saslFactories = SaslUtils.getSaslServerFactories(SaslUtils.class.getClassLoader(), true); while (saslFactories.hasNext()) { SaslServerFactory saslFactory = saslFactories.next(); for (String supportedMech : saslFactory.getMechanismNames(props)) { if (supportedMech.equals(mech)) { return saslFactory; } } } throw new IllegalArgumentException("No SASL server factory for mech " + mech); }
public SaslServer createSaslServer(final String mechanism, final String protocol, final String serverName, final Map<String, ?> props, final CallbackHandler cbh) throws SaslException { return predicate.test(mechanism) ? delegate.createSaslServer(mechanism, protocol, serverName, props, cbh) : null; }
FastSaslServerFactory(Map<String,?> props) { final Enumeration<SaslServerFactory> factories = Sasl.getSaslServerFactories(); while (factories.hasMoreElements()) { SaslServerFactory factory = factories.nextElement(); for (String mech : factory.getMechanismNames(props)) { if (!factoryCache.containsKey(mech)) { factoryCache.put(mech, new ArrayList<SaslServerFactory>()); } factoryCache.get(mech).add(factory); } } }
@Override public SaslServer createSaslServer(String mechanism, String protocol, String serverName, Map<String,?> props, CallbackHandler cbh) throws SaslException { SaslServer saslServer = null; List<SaslServerFactory> factories = factoryCache.get(mechanism); if (factories != null) { for (SaslServerFactory factory : factories) { saslServer = factory.createSaslServer( mechanism, protocol, serverName, props, cbh); if (saslServer != null) { break; } } } return saslServer; }
public String[] getMechanismNames(final Map<String, ?> props) { synchronized (loader){ final Set<String> set = new LinkedHashSet<>(); final Iterator<SaslServerFactory> iterator = loader.iterator(); SaslServerFactory serverFactory; for (; ; ) try { // Service loader iterators can blow up in various ways; that's why the loop is structured this way if (!iterator.hasNext()) { break; } serverFactory = iterator.next(); // let SaslException bubble up Collections.addAll(set, serverFactory.getMechanismNames(props)); } catch (ServiceConfigurationError ignored) { } return set.toArray(new String[set.size()]); } } }
public SaslServer createSaslServer(final String mechanism, final String protocol, final String serverName, final Map<String, ?> props, final CallbackHandler cbh) throws SaslException { final SaslServer delegateSaslServer = delegate.createSaslServer(mechanism, protocol, serverName, props, cbh); return delegateSaslServer == null ? null : new AbstractDelegatingSaslServer(delegateSaslServer) { private final AtomicBoolean complete = new AtomicBoolean();
/** * Returns a collection of mechanism names for which the JVM has an implementation available. * <p/> * Note that this need not (and likely will not) correspond with the list of mechanisms that is offered to XMPP * peer entities, which is provided by #getSupportedMechanisms. * * @return a collection of SASL mechanism names (never null, possibly empty) */ public static Set<String> getImplementedMechanisms() { final Set<String> result = new HashSet<>(); final Enumeration<SaslServerFactory> saslServerFactories = Sasl.getSaslServerFactories(); while ( saslServerFactories.hasMoreElements() ) { final SaslServerFactory saslServerFactory = saslServerFactories.nextElement(); Collections.addAll( result, saslServerFactory.getMechanismNames( null ) ); } return result; }
public SaslServer createSaslServer(final String mechanism, final String protocol, final String serverName, final Map<String, ?> props, final CallbackHandler cbh) throws SaslException { return delegate.createSaslServer(mechanism, protocol, serverName, props, new SocketAddressQueryCallbackHandler(cbh, localAddress, peerAddress)); } }
@Override public String[] getMechanismNames(final Map<String, ?> props) { final BiPredicate<String, Provider> mechFilter = SaslFactories.getProviderFilterPredicate(props); final Set<String> names = new LinkedHashSet<>(); for (Provider currentProvider : providerSupplier.get()) { Set<Service> services = currentProvider.getServices(); if (services != null) { for (Service service : services) { if (SERVICE_TYPE.equals(service.getType())) { try { final String[] mechanismNames = ((SaslServerFactory) service.newInstance(null)).getMechanismNames(props); Collections.addAll(names, SaslFactories.filterMechanismsByProvider(mechanismNames, 0, 0, currentProvider, mechFilter)); } catch (NoSuchAlgorithmException | ClassCastException | InvalidParameterException e) { log.debug("Unable to create instance", e); } } } } } if (names.size() == 0 && log.isTraceEnabled()) { log.tracef("No %s provided by provider supplier in %s: %s", SERVICE_TYPE, getClass().getSimpleName(), Arrays.toString(providerSupplier.get())); } return names.toArray(new String[names.size()]); } }
@Override public SaslServer createSaslServer(final String mechanism, final String protocol, final String serverName, final Map<String, ?> props, final CallbackHandler cbh) throws SaslException { final SaslServer delegateSaslServer = delegate.createSaslServer(mechanism, protocol, serverName, props, cbh); return delegateSaslServer == null ? null : new AbstractDelegatingSaslServer(delegateSaslServer) { private final AtomicBoolean complete = new AtomicBoolean();