protected void process()

in sshd-core/src/main/java/org/apache/sshd/agent/common/AbstractAgentClient.java [95:190]
95 lines of code
18 McCabe index (conditional complexity)

    protected void process(int cmd, Buffer req, Buffer rep) throws Exception {
        boolean debugEnabled = log.isDebugEnabled();
        if (debugEnabled) {
            log.debug("process(cmd={})", SshAgentConstants.getCommandMessageName(cmd));
        }
        switch (cmd) {
            case SshAgentConstants.SSH2_AGENTC_REQUEST_IDENTITIES: {
                Iterable<? extends Map.Entry<PublicKey, String>> ids = agent.getIdentities();
                Collection<? extends Map.Entry<PublicKey, String>> keys;
                if (ids instanceof Collection<?>) {
                    keys = (Collection<? extends Map.Entry<PublicKey, String>>) ids;
                } else {
                    Collection<Map.Entry<PublicKey, String>> c = new LinkedList<>();
                    for (Map.Entry<PublicKey, String> i : ids) {
                        c.add(i);
                    }
                    keys = c;
                }

                rep.putByte(SshAgentConstants.SSH2_AGENT_IDENTITIES_ANSWER);
                rep.putUInt(keys.size());
                for (Map.Entry<PublicKey, String> key : keys) {
                    rep.putPublicKey(key.getKey());
                    rep.putString(key.getValue());
                }
                break;
            }
            case SshAgentConstants.SSH2_AGENTC_SIGN_REQUEST: {
                PublicKey signingKey = req.getPublicKey();
                byte[] data = req.getBytes();
                int flags = req.getInt();
                if (debugEnabled) {
                    log.debug("SSH2_AGENTC_SIGN_REQUEST key={}, flags=0x{}, data={}",
                            signingKey.getAlgorithm(), Integer.toHexString(flags), BufferUtils.toHex(':', data));
                }
                String keyType = ValidateUtils.checkNotNullAndNotEmpty(
                        KeyUtils.getKeyType(signingKey),
                        "Cannot resolve key type of %s",
                        signingKey.getClass().getSimpleName());
                String signatureAlgorithm = keyType;
                if (KeyPairProvider.SSH_RSA.equals(keyType)) {
                    switch (flags) {
                        case 4:
                            signatureAlgorithm = KeyUtils.RSA_SHA512_KEY_TYPE_ALIAS;
                            break;
                        case 2:
                            signatureAlgorithm = KeyUtils.RSA_SHA256_KEY_TYPE_ALIAS;
                            break;
                        case 0:
                            break;
                        default:
                            throw new IllegalArgumentException("SSH2_AGENTC_SIGN_REQUEST: Unknown flag value 0x"
                                                               + Integer.toHexString(flags) + ", only 0, 2, or 4 are allowed.");
                    }
                }
                Map.Entry<String, byte[]> result = agent.sign(null, signingKey, signatureAlgorithm, data);
                String algo = result.getKey();
                byte[] signature = result.getValue();
                Buffer sig = new ByteArrayBuffer(algo.length() + signature.length + Long.SIZE, false);
                sig.putString(algo);
                sig.putBytes(signature);
                rep.putByte(SshAgentConstants.SSH2_AGENT_SIGN_RESPONSE);
                rep.putBytes(sig.array(), sig.rpos(), sig.available());
                break;
            }
            case SshAgentConstants.SSH2_AGENTC_ADD_IDENTITY: {
                KeyPair keyToAdd = req.getKeyPair();
                String comment = req.getString();
                if (debugEnabled) {
                    log.debug("SSH2_AGENTC_ADD_IDENTITY comment={}", comment);
                }
                agent.addIdentity(keyToAdd, comment);
                rep.putByte(SshAgentConstants.SSH_AGENT_SUCCESS);
                break;
            }
            case SshAgentConstants.SSH2_AGENTC_REMOVE_IDENTITY: {
                PublicKey keyToRemove = req.getPublicKey();
                if (debugEnabled) {
                    log.debug("SSH2_AGENTC_REMOVE_IDENTITY {}", keyToRemove.getClass().getSimpleName());
                }
                agent.removeIdentity(keyToRemove);
                rep.putByte(SshAgentConstants.SSH_AGENT_SUCCESS);
                break;
            }
            case SshAgentConstants.SSH2_AGENTC_REMOVE_ALL_IDENTITIES:
                agent.removeAllIdentities();
                rep.putByte(SshAgentConstants.SSH_AGENT_SUCCESS);
                break;
            default:
                if (debugEnabled) {
                    log.debug("Unknown command: {}", SshAgentConstants.getCommandMessageName(cmd));
                }
                rep.putByte(SshAgentConstants.SSH2_AGENT_FAILURE);
                break;
        }
    }