protected void setPasswordCallbackValue(Object thePass, PasswordCallback passwdCallback) { String tmp; if (thePass instanceof String) { tmp = (String) thePass; passwdCallback.setPassword(tmp.toCharArray()); } else if (thePass instanceof char[]) { passwdCallback.setPassword((char[]) thePass); } else if (thePass instanceof byte[]) { byte[] theBytes = (byte[]) thePass; passwdCallback.setPassword((new String(theBytes).toCharArray())); } else { throw PicketBoxMessages.MESSAGES.invalidPasswordType( thePass != null ? thePass.getClass() : null); } }
/** * If the callback passed to the 'handle' method is an instance of PasswordCallback, the * JaasPasswordCallbackHandler will call, * callback.setPassword(authentication.getCredentials().toString()). * * @param callback * @param auth * @throws IOException * @throws UnsupportedCallbackException */ public void handle(Callback callback, Authentication auth) throws IOException, UnsupportedCallbackException { if (callback instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) callback; pc.setPassword(auth.getCredentials().toString().toCharArray()); } }
protected AuthContext authenticate( String orgname, String username, String password, PrintWriter out) throws Exception { // Authenticate the user and obtain SSO Token AuthContext lc = new AuthContext(orgname); lc.login(); while (lc.hasMoreRequirements()) { Callback[] callbacks = lc.getRequirements(); for (int i = 0; i < callbacks.length; i++) { if (callbacks[i] instanceof NameCallback) { NameCallback nc = (NameCallback) callbacks[i]; nc.setName(username); } else if (callbacks[i] instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) callbacks[i]; pc.setPassword(password.toCharArray()); } else { out.println("Unknow Callback: " + callbacks[i]); out.println("</body></html>"); return null; } } lc.submitRequirements(callbacks); } if (lc.getStatus() != AuthContext.Status.SUCCESS) { out.println("Invalid credentials"); out.println("</body></html>"); return null; } return lc; }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { NameCallback nc = null; PasswordCallback pc = null; AuthorizeCallback ac = null; for (Callback callback : callbacks) { if (callback instanceof AuthorizeCallback) { ac = (AuthorizeCallback) callback; } else if (callback instanceof NameCallback) { nc = (NameCallback) callback; } else if (callback instanceof PasswordCallback) { pc = (PasswordCallback) callback; } else if (callback instanceof RealmCallback) { continue; // realm is ignored } else { throw new UnsupportedCallbackException( callback, "handle: Unrecognized SASL DIGEST-MD5 Callback"); } } if (nc != null) { LOG.debug( "handle: SASL server DIGEST-MD5 callback: setting " + "username for client: " + userName); nc.setName(userName); } if (pc != null) { char[] password = SaslUtils.encodePassword(userPassword); LOG.debug( "handle: SASL server DIGEST-MD5 callback: setting " + "password for client: " + userPassword); pc.setPassword(password); } if (ac != null) { String authid = ac.getAuthenticationID(); String authzid = ac.getAuthorizationID(); if (authid.equals(authzid)) { ac.setAuthorized(true); } else { ac.setAuthorized(false); } if (ac.isAuthorized()) { LOG.debug( "handle: SASL server DIGEST-MD5 callback: setting " + "canonicalized client ID: " + userName); ac.setAuthorizedID(authzid); } } }
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback current : callbacks) { if (current instanceof NameCallback) { NameCallback ncb = (NameCallback) current; ncb.setName(username); } else if (current instanceof PasswordCallback && password != null) { PasswordCallback pcb = (PasswordCallback) current; pcb.setPassword(password); } else if (current instanceof DigestHashCallback && hexURPHash != null) { DigestHashCallback dhc = (DigestHashCallback) current; dhc.setHexHash(hexURPHash); } else if (current instanceof RealmCallback) { RealmCallback rcb = (RealmCallback) current; if (realm == null) { String defaultText = rcb.getDefaultText(); if (defaultText != null && defaultText.length() > 0) { rcb.setText(defaultText); } } else { rcb.setText(realm); } } else { throw new UnsupportedCallbackException( current, current.getClass().getSimpleName() + " not supported."); } } }
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback c : callbacks) { if (c instanceof NameCallback) { String username = userIdent.getUserName(); NameCallback nc = (NameCallback) c; nc.setName(username); } else if (c instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) c; char[] password = userIdent.getPassword().toCharArray(); pc.setPassword(password); } else if (c instanceof UserIdentificationInfoCallback) { UserIdentificationInfoCallback uic = (UserIdentificationInfoCallback) c; uic.setUserInfo(userIdent); } else if (c.getClass() .getName() .equals("org.jboss.security.auth.callback.SecurityAssociationCallback")) { // we do nothing but do not raise error } else { throw new UnsupportedCallbackException( c, "Unrecognized Callback:" + c.getClass().getName()); } } }
// TODO:V3 trying to read system properties here protected void handleSupportedCallbacks(Callback[] callbacks) throws IOException, UnsupportedCallbackException { // this variable is set to true if we have used the older jaas // mechanisms to process the callbacks - and we will not need // to process further as the inside loop, just takes care // of processing all callbacks boolean processedSomeAppclientCallbacks = false; int i = 0; while (i < callbacks.length) { if (!processedSomeAppclientCallbacks) { if ((callbacks[i] instanceof NameCallback) || (callbacks[i] instanceof PasswordCallback) || (callbacks[i] instanceof ChoiceCallback)) { String loginName = UsernamePasswordStore.getUsername(); char[] password = UsernamePasswordStore.getPassword(); boolean doSet = false; if (loginName == null) { loginName = System.getProperty(LOGIN_NAME); doSet = true; } if (password == null) { password = System.getProperty(LOGIN_PASSWORD).toCharArray(); doSet = true; } if (doSet) { UsernamePasswordStore.set(loginName, password); } // TODO: V3 CallbackHandler callbackHandler = AppContainer.getCallbackHandler(); CallbackHandler callbackHandler = SecurityServicesUtil.getInstance().getCallbackHandler(); if (loginName != null && password != null) { // username/password set already for (Callback callback : callbacks) { if (callback instanceof NameCallback) { NameCallback nc = (NameCallback) callback; nc.setName(loginName); } else if (callback instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) callback; pc.setPassword(password); } } } else { // once this is called all callbacks will be handled by // callbackHandler and then we dont have to check for // NameCallback PasswordCallback and ChoiceCallback // again. // Let control flow to the callback processors callbackHandler.handle(callbacks); } processedSomeAppclientCallbacks = true; break; } } processCallback(callbacks[i]); i++; } }
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { List<Callback> toRespondTo = new LinkedList<Callback>(); String userName = null; boolean userFound = false; // A single pass may be sufficient but by using a two pass approach the Callbackhandler will not // fail if an unexpected order is encountered. // First Pass - is to double check no unsupported callbacks and to retrieve // information from the callbacks passing in information. Properties users = getUsersProperties(); for (Callback current : callbacks) { if (current instanceof AuthorizeCallback) { toRespondTo.add(current); } else if (current instanceof NameCallback) { NameCallback nameCallback = (NameCallback) current; userName = nameCallback.getDefaultName(); userFound = users.containsKey(userName); } else if (current instanceof PasswordCallback && plainText) { toRespondTo.add(current); } else if (current instanceof DigestHashCallback && plainText == false) { toRespondTo.add(current); } else if (current instanceof RealmCallback) { String realm = ((RealmCallback) current).getDefaultText(); if (this.realm.equals(realm) == false) { throw new IllegalStateException( "Invalid Realm '" + realm + "' expected '" + this.realm + "'"); } } else { throw new UnsupportedCallbackException(current); } } // Second Pass - Now iterate the Callback(s) requiring a response. for (Callback current : toRespondTo) { if (current instanceof AuthorizeCallback) { AuthorizeCallback authorizeCallback = (AuthorizeCallback) current; // Don't support impersonating another identity authorizeCallback.setAuthorized( authorizeCallback.getAuthenticationID().equals(authorizeCallback.getAuthorizationID())); } else if (current instanceof PasswordCallback) { if (userFound == false) { throw new UserNotFoundException(userName); } String password = users.get(userName).toString(); ((PasswordCallback) current).setPassword(password.toCharArray()); } else if (current instanceof DigestHashCallback) { if (userFound == false) { throw new UserNotFoundException(userName); } String hash = users.get(userName).toString(); ((DigestHashCallback) current).setHexHash(hash); } } }
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof NameCallback) { ((NameCallback) callback).setName(login); } if (callback instanceof PasswordCallback) { ((PasswordCallback) callback).setPassword(password.toCharArray()); } } }
public Collection<Callback> get() { Collection<Callback> callbacks = new ArrayList<Callback>(); NameCallback nameCallback = new NameCallback(NAME, GUEST); nameCallback.setName(GUEST); callbacks.add(nameCallback); PasswordCallback passwordCallback = new PasswordCallback(PASSWORD, true); passwordCallback.setPassword(GUEST.toCharArray()); callbacks.add(passwordCallback); return callbacks; }
public void setPassword(Principal principal, PasswordCallback callback) throws IOException, AccountNotFoundException { // Let the read DB set the password _realPricipalDatabase.setPassword(principal, callback); // Retrieve the setpassword char[] plainPassword = callback.getPassword(); char[] hexPassword = toHex(plainPassword); callback.setPassword(hexPassword); }
/** {@inheritDoc} */ @Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { NameCallback nc = null; PasswordCallback pc = null; AuthorizeCallback ac = null; for (Callback callback : callbacks) { if (callback instanceof AuthorizeCallback) { ac = (AuthorizeCallback) callback; } else if (callback instanceof NameCallback) { nc = (NameCallback) callback; } else if (callback instanceof PasswordCallback) { pc = (PasswordCallback) callback; } else if (callback instanceof RealmCallback) { continue; // realm is ignored } else { throw new UnsupportedCallbackException( callback, "handle: Unrecognized SASL DIGEST-MD5 Callback"); } } if (pc != null) { JobTokenIdentifier tokenIdentifier = getIdentifier(nc.getDefaultName(), secretManager); char[] password = encodePassword(secretManager.retrievePassword(tokenIdentifier)); if (LOG.isDebugEnabled()) { LOG.debug( "handle: SASL server DIGEST-MD5 callback: setting " + "password for client: " + tokenIdentifier.getUser()); } pc.setPassword(password); } if (ac != null) { String authid = ac.getAuthenticationID(); String authzid = ac.getAuthorizationID(); if (authid.equals(authzid)) { ac.setAuthorized(true); } else { ac.setAuthorized(false); } if (ac.isAuthorized()) { if (LOG.isDebugEnabled()) { String username = getIdentifier(authzid, secretManager).getUser().getUserName(); if (LOG.isDebugEnabled()) { LOG.debug( "handle: SASL server DIGEST-MD5 callback: setting " + "canonicalized client ID: " + username); } } ac.setAuthorizedID(authzid); } } }
public void handle(Callback[] callbacks) throws UnsupportedCallbackException { for (int i = 0; i < callbacks.length; i++) { if (callbacks[i] instanceof NameCallback) { // prompt the user for a username NameCallback nc = (NameCallback) callbacks[i]; nc.setName(userid); } else if (callbacks[i] instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) callbacks[i]; pc.setPassword(password.toCharArray()); } } }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof NameCallback) { NameCallback nameCallback = (NameCallback) callback; nameCallback.setName(getUserName()); } else if (callback instanceof PasswordCallback) { PasswordCallback passwordCallback = (PasswordCallback) callback; passwordCallback.setPassword(getPassword().toCharArray()); } else { throw new UnsupportedCallbackException(callback); } } }
@Override public void handle(final Callback[] cb) throws IOException, UnsupportedCallbackException { for (final Callback element : cb) { if (element instanceof NameCallback) { final NameCallback nc = (NameCallback) element; nc.setName(this.username); } else if (element instanceof PasswordCallback) { final PasswordCallback pc = (PasswordCallback) element; pc.setPassword(this.password == null ? null : this.password.toCharArray()); } else { throw new UnsupportedCallbackException(element, "UsernamePasswordCallbackHandler"); } } }
public void handle(Callback[] callbacks) throws java.io.IOException, UnsupportedCallbackException { for (int i = 0; i < callbacks.length; i++) { if (callbacks[i] instanceof NameCallback) { NameCallback nc = (NameCallback) callbacks[i]; nc.setName(username); } else if (callbacks[i] instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) callbacks[i]; pc.setPassword(password.toCharArray()); } else { throw new UnsupportedCallbackException(callbacks[i], "Unrecognized Callback"); } } }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof NameCallback) { ((NameCallback) callback).setName(login); } else if (callback instanceof PasswordCallback) { ((PasswordCallback) callback).setPassword(password.toCharArray()); } else if (callback instanceof RealmCallback) { ((RealmCallback) callback).setText(realm); } else { throw new UnsupportedCallbackException(callback); } } }
public void handle(Callback[] callbacks) { String user = OneKDC.USER; char[] pass = OneKDC.PASS; for (Callback callback : callbacks) { if (callback instanceof NameCallback) { System.out.println("Callback for name: " + user); ((NameCallback) callback).setName(user); } if (callback instanceof PasswordCallback) { System.out.println("Callback for pass: " + new String(pass)); ((PasswordCallback) callback).setPassword(pass); } } }
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback cb : callbacks) { if (cb instanceof TextOutputCallback) { // Not implementing this one yet... } else if (cb instanceof NameCallback) { NameCallback nc = (NameCallback) cb; nc.setName(username); } else if (cb instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) cb; pc.setPassword(password); } else { throw new UnsupportedCallbackException(cb); } } }
/** {@inheritDoc} */ @Override public void handle(final Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback cb : callbacks) { if (cb instanceof NameCallback) { // if user is null, the authzId will be used as it's the default name ((NameCallback) cb).setName(user != null ? user : ((NameCallback) cb).getDefaultName()); } else if (cb instanceof PasswordCallback) { ((PasswordCallback) cb).setPassword(pass); } else if (cb instanceof RealmCallback) { ((RealmCallback) cb).setText(((RealmCallback) cb).getDefaultText()); } else if (cb instanceof RealmChoiceCallback) { ((RealmChoiceCallback) cb).setSelectedIndex(0); } } }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback current : callbacks) { if (current instanceof NameCallback) { NameCallback ncb = (NameCallback) current; ncb.setName(this.userName); } else if (current instanceof PasswordCallback) { PasswordCallback pcb = (PasswordCallback) current; pcb.setPassword(this.password.toCharArray()); } else if (current instanceof RealmCallback) { RealmCallback rcb = (RealmCallback) current; rcb.setText(rcb.getDefaultText()); } else { throw new UnsupportedCallbackException(current); } } }
/** * The handler sets for instances of {@link NameCallBack} the given {@link #name} and for * instances of {@link PasswordCallBack} the given {@link #password}. {@link TextOutputCallBack} * instances are ignored. * * @param _callbacks callback instances to handle * @throws UnsupportedCallbackException for all {@link Callback} instances which are not {@link * NameCallBack}, {@link PasswordCallBack} or {@link TextOutputCallBack}. */ public void handle(final Callback[] _callbacks) throws IOException, UnsupportedCallbackException { for (int i = 0; i < _callbacks.length; i++) { if (_callbacks[i] instanceof TextOutputCallback) { // do nothing, TextOutputCallBack's are ignored! } else if (_callbacks[i] instanceof NameCallback) { NameCallback nc = (NameCallback) _callbacks[i]; nc.setName(this.name); } else if (_callbacks[i] instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) _callbacks[i]; pc.setPassword(this.password.toCharArray()); } else { throw new UnsupportedCallbackException(_callbacks[i], "Unrecognized Callback"); } } }
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (int i = 0; i < callbacks.length; i++) { if (callbacks[i] instanceof NameCallback) { NameCallback ncb = (NameCallback) callbacks[i]; ncb.setName(authenticationId); } else if (callbacks[i] instanceof PasswordCallback) { PasswordCallback pcb = (PasswordCallback) callbacks[i]; pcb.setPassword(password.toCharArray()); } else if (callbacks[i] instanceof RealmCallback) { RealmCallback rcb = (RealmCallback) callbacks[i]; rcb.setText(hostname); } else if (callbacks[i] instanceof RealmChoiceCallback) { // unused // RealmChoiceCallback rccb = (RealmChoiceCallback)callbacks[i]; } else { throw new UnsupportedCallbackException(callbacks[i]); } } }
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback current : callbacks) { if (current instanceof RealmCallback) { RealmCallback rcb = (RealmCallback) current; String defaultText = rcb.getDefaultText(); rcb.setText(defaultText); // For now just use the realm suggested. } else if (current instanceof RealmChoiceCallback) { throw new UnsupportedCallbackException(current, "Realm choice not currently supported."); } else if (current instanceof NameCallback) { NameCallback ncb = (NameCallback) current; ncb.setName(serverName); } else if (current instanceof PasswordCallback) { PasswordCallback pcb = (PasswordCallback) current; pcb.setPassword(new String(authKey).toCharArray()); } else { throw new UnsupportedCallbackException(current); } } }
@Override public void handle(Callback[] callbacks) throws UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof NameCallback) { NameCallback nameCallback = (NameCallback) callback; nameCallback.setName(_name); } else if (callback instanceof PasswordCallback) { String password = GetterUtil.getString(_password); PasswordCallback passwordCallback = (PasswordCallback) callback; passwordCallback.setPassword(password.toCharArray()); } else { throw new UnsupportedCallbackException(callback); } } }
@Override public byte[] evaluateResponse(byte[] response) throws SaslException { if (completed) { throw new IllegalStateException("PLAIN authentication has completed"); } if (response == null) { throw new IllegalArgumentException("Received null response"); } try { String payload; try { payload = new String(response, "UTF-8"); } catch (Exception e) { throw new IllegalArgumentException("Received corrupt response", e); } // [ authz, authn, password ] String[] parts = payload.split("\u0000", 3); if (parts.length != 3) { throw new IllegalArgumentException("Received corrupt response"); } if (parts[0].isEmpty()) { // authz = authn parts[0] = parts[1]; } NameCallback nc = new NameCallback("SASL PLAIN"); nc.setName(parts[1]); PasswordCallback pc = new PasswordCallback("SASL PLAIN", false); pc.setPassword(parts[2].toCharArray()); AuthorizeCallback ac = new AuthorizeCallback(parts[1], parts[0]); cbh.handle(new Callback[] {nc, pc, ac}); if (ac.isAuthorized()) { authz = ac.getAuthorizedID(); } } catch (Exception e) { throw new SaslException("PLAIN auth failed: " + e.toString(), e); } finally { completed = true; } return null; }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof NameCallback) { NameCallback nameCallback = (NameCallback) callback; nameCallback.setName("user"); } else if (callback instanceof PasswordCallback) { PasswordCallback passwordCallback = (PasswordCallback) callback; passwordCallback.setPassword(password.toCharArray()); } else if (callback instanceof AuthorizeCallback) { AuthorizeCallback authorizeCallback = (AuthorizeCallback) callback; authorizeCallback.setAuthorized( authorizeCallback .getAuthenticationID() .equals(authorizeCallback.getAuthorizationID())); } else if (callback instanceof RealmCallback) { RealmCallback realmCallback = (RealmCallback) callback; realmCallback.setText(REALM); } else { throw new UnsupportedCallbackException(callback); } } }
/* * process callbacks */ private void processRequirements( String xml, AuthContextLocal authContext, AuthXMLResponse authResponse, String params, HttpServletRequest servletRequest) { String[] paramArray = null; StringTokenizer paramsSet = null; if (params != null) { paramsSet = new StringTokenizer(params, ISAuthConstants.PIPE_SEPARATOR); } boolean allCallbacksAreSet = true; String param; while (authContext.hasMoreRequirements()) { Callback[] reqdCallbacks = authContext.getRequirements(); for (int i = 0; i < reqdCallbacks.length; i++) { if (reqdCallbacks[i] instanceof X509CertificateCallback) { X509CertificateCallback certCallback = (X509CertificateCallback) reqdCallbacks[i]; LoginState loginState = AuthUtils.getLoginState(authContext); if (loginState != null) { X509Certificate cert = loginState.getX509Certificate(servletRequest); if (cert != null) { certCallback.setCertificate(cert); certCallback.setReqSignature(false); } else { allCallbacksAreSet = false; } } } else { param = null; if (reqdCallbacks[i] instanceof NameCallback) { param = getNextParam(paramsSet); if (param != null) { NameCallback nc = (NameCallback) reqdCallbacks[i]; nc.setName(param); if (messageEnabled) { debug.message("Name callback set to " + param); } } else { allCallbacksAreSet = false; break; } } else if (reqdCallbacks[i] instanceof PasswordCallback) { param = getNextParam(paramsSet); if (param != null) { PasswordCallback pc = (PasswordCallback) reqdCallbacks[i]; pc.setPassword(param.toCharArray()); if (messageEnabled) { debug.message("Password callback is set"); } } else { allCallbacksAreSet = false; break; } } else { if (params == null) { allCallbacksAreSet = false; } } // add more callbacks if required } } if (getNextParam(paramsSet) != null) { allCallbacksAreSet = false; } if (allCallbacksAreSet) { if (messageEnabled) { debug.message("submit callbacks with passed in params"); } authContext.submitRequirements(reqdCallbacks); } else { authResponse.setReqdCallbacks(reqdCallbacks); break; } } if (!authContext.hasMoreRequirements()) { AuthContext.Status loginStatus = authContext.getStatus(); if (messageEnabled) { debug.message(" Status: " + loginStatus); } authResponse.setLoginStatus(loginStatus); } }
@Override public synchronized void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { final Console console = System.console(); if (console == null) throw new IOException("Console not available"); for (Callback callback : callbacks) { if (callback instanceof PasswordCallback) { final PasswordCallback password = (PasswordCallback) callback; final String prompt = getDefault(password.getPrompt(), "Enter password"); char[] answer = console.readPassword("\u001b[34m%s\u001b[0m: ", prompt); if (answer == null) throw new EOFException(); password.setPassword(answer); } else if (callback instanceof NameCallback) { final NameCallback name = (NameCallback) callback; final String prompt = getDefault(name.getPrompt(), "Enter name"); final String defaultName = name.getDefaultName(); if (defaultName == null) while (true) { final String answer = console.readLine("\u001b[34m%s\u001b[0m: ", prompt); if (answer == null) throw new EOFException(); if (answer.length() == 0) continue; name.setName(answer); break; } else { final String answer = console.readLine( "\u001b[34m%s\u001b[0m [\u001b[36m%s\u001b[0m]: ", prompt, defaultName); if (answer == null) throw new EOFException(); if (answer.length() == 0) name.setName(defaultName); else name.setName(answer); } } else if (callback instanceof TextInputCallback) { final TextInputCallback input = (TextInputCallback) callback; final String prompt = getDefault(input.getPrompt(), "Enter value"); final String defaultText = input.getDefaultText(); if (defaultText == null) while (true) { final String answer = console.readLine("\u001b[34m%s\u001b[0m: ", prompt); if (answer == null) throw new EOFException(); if (answer.length() == 0) continue; input.setText(answer); break; } else { final String answer = console.readLine( "\u001b[34m%s\u001b[0m [\u001b[36m%s\u001b[0m]: ", prompt, defaultText); if (answer == null) throw new EOFException(); if (answer.length() == 0) input.setText(defaultText); else input.setText(answer); } } else if (callback instanceof TextOutputCallback) { final TextOutputCallback output = (TextOutputCallback) callback; final String message = output.getMessage(); switch (output.getMessageType()) { case TextOutputCallback.INFORMATION: console.format("\u001b[32m%s\u001b[0m\n", message); break; case TextOutputCallback.WARNING: console.format("\u001b[33mWARNING: %s\u001b[0m\n", message); break; case TextOutputCallback.ERROR: console.format("\u001b[31mERROR: %s\u001b[0m\n", message); break; default: console.format("\u001b[35m??? [%d]: %s\u001b[0m\n", output.getMessageType(), message); break; } } else { throw new UnsupportedCallbackException(callback, "Callback type not supported"); } } }
/** * Describe <code>handle</code> method here. * * @param callbacks a <code>Callback[]</code> value * @exception IOException if an error occurs * @exception UnsupportedCallbackException if an error occurs */ @Override public void handle(final Callback[] callbacks) throws IOException, UnsupportedCallbackException { BareJID jid = null; for (int i = 0; i < callbacks.length; i++) { if (log.isLoggable(Level.FINEST)) { log.finest("Callback: " + callbacks[i].getClass().getSimpleName()); } if (callbacks[i] instanceof RealmCallback) { RealmCallback rc = (RealmCallback) callbacks[i]; String realm = (String) options.get(REALM_KEY); if (realm != null) { rc.setText(realm); } // end of if (realm == null) if (log.isLoggable(Level.FINEST)) { log.finest("RealmCallback: " + realm); } } else { if (callbacks[i] instanceof NameCallback) { NameCallback nc = (NameCallback) callbacks[i]; String user_name = nc.getName(); if (user_name == null) { user_name = nc.getDefaultName(); } // end of if (name == null) jid = BareJID.bareJIDInstanceNS(user_name, (String) options.get(REALM_KEY)); options.put(USER_ID_KEY, jid); if (log.isLoggable(Level.FINEST)) { log.finest("NameCallback: " + user_name); } } else { if (callbacks[i] instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) callbacks[i]; try { String passwd = getPassword(jid); pc.setPassword(passwd.toCharArray()); if (log.isLoggable(Level.FINEST)) { log.finest("PasswordCallback: " + passwd); } } catch (Exception e) { throw new IOException("Password retrieving problem.", e); } // end of try-catch } else { if (callbacks[i] instanceof AuthorizeCallback) { AuthorizeCallback authCallback = ((AuthorizeCallback) callbacks[i]); String authenId = authCallback.getAuthenticationID(); String authorId = authCallback.getAuthorizationID(); if (log.isLoggable(Level.FINEST)) { log.finest("AuthorizeCallback: authenId: " + authenId); log.finest("AuthorizeCallback: authorId: " + authorId); } // if (authenId.equals(authorId)) { authCallback.setAuthorized(true); // } // end of if (authenId.equals(authorId)) } else { throw new UnsupportedCallbackException(callbacks[i], "Unrecognized Callback"); } } } } } }