/*

 * options.c - handle pre-connection options

 *

 * This file is part of the SSH Library

 *

 * Copyright (c) 2003-2008 by Aris Adamantiadis

 * Copyright (c) 2009-2013 by Andreas Schneider <asn@cryptomilk.org>

 *

 * The SSH Library is free software; you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation; either version 2.1 of the License, or (at your

 * option) any later version.

 *

 * The SSH Library is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public

 * License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with the SSH Library; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,

 * MA 02111-1307, USA.

 */

#include "config.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifndef _WIN32

#include <pwd.h>

#else

#include <winsock2.h>

#endif

#include <sys/types.h>

#include "libssh/priv.h"

#include "libssh/session.h"

#include "libssh/misc.h"

#include "libssh/options.h"

#ifdef WITH_SERVER

#include "libssh/server.h"

#include "libssh/bind.h"

#include "libssh/bind_config.h"

#endif

/**

 * @addtogroup libssh_session

 * @{

 */

/**

 * @brief Duplicate the options of a session structure.

 *

 * If you make several sessions with the same options this is useful. You

 * cannot use twice the same option structure in ssh_session_connect.

 *

 * @param src           The session to use to copy the options.

 *

 * @param dest          A pointer to store the allocated session with duplicated

 *                      options. You have to free the memory.

 *

 * @returns             0 on sucess, -1 on error with errno set.

 *

 * @see ssh_session_connect()

 */

int ssh_options_copy(ssh_session src, ssh_session *dest)

{

    ssh_session new;

    struct ssh_iterator *it = NULL;

    char *id = NULL;

    int i;

    if (src == NULL || dest == NULL) {

        return -1;

    }

    new = ssh_new();

    if (new == NULL) {

        return -1;

    }

    if (src->opts.username != NULL) {

        new->opts.username = strdup(src->opts.username);

        if (new->opts.username == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    if (src->opts.host != NULL) {

        new->opts.host = strdup(src->opts.host);

        if (new->opts.host == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    if (src->opts.bindaddr != NULL) {

        new->opts.bindaddr = strdup(src->opts.bindaddr);

        if (new->opts.bindaddr == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    /* Remove the default identities */

    for (id = ssh_list_pop_head(char *, new->opts.identity);

         id != NULL;

         id = ssh_list_pop_head(char *, new->opts.identity)) {

        SAFE_FREE(id);

    }

    /* Copy the new identities from the source list */

    if (src->opts.identity != NULL) {

        it = ssh_list_get_iterator(src->opts.identity);

        while (it) {

            int rc;

            id = strdup((char *) it->data);

            if (id == NULL) {

                ssh_free(new);

                return -1;

            }

            rc = ssh_list_append(new->opts.identity, id);

            if (rc < 0) {

                free(id);

                ssh_free(new);

                return -1;

            }

            it = it->next;

        }

    }

    if (src->opts.sshdir != NULL) {

        new->opts.sshdir = strdup(src->opts.sshdir);

        if (new->opts.sshdir == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    if (src->opts.knownhosts != NULL) {

        new->opts.knownhosts = strdup(src->opts.knownhosts);

        if (new->opts.knownhosts == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    if (src->opts.global_knownhosts != NULL) {

        new->opts.global_knownhosts = strdup(src->opts.global_knownhosts);

        if (new->opts.global_knownhosts == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    for (i = 0; i < SSH_KEX_METHODS; i++) {

        if (src->opts.wanted_methods[i] != NULL) {

            new->opts.wanted_methods[i] = strdup(src->opts.wanted_methods[i]);

            if (new->opts.wanted_methods[i] == NULL) {

                ssh_free(new);

                return -1;

            }

        }

    }

    if (src->opts.ProxyCommand != NULL) {

        new->opts.ProxyCommand = strdup(src->opts.ProxyCommand);

        if (new->opts.ProxyCommand == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    if (src->opts.pubkey_accepted_types != NULL) {

        new->opts.pubkey_accepted_types = strdup(src->opts.pubkey_accepted_types);

        if (new->opts.pubkey_accepted_types == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    if (src->opts.gss_server_identity != NULL) {

        new->opts.gss_server_identity = strdup(src->opts.gss_server_identity);

        if (new->opts.gss_server_identity == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    if (src->opts.gss_client_identity != NULL) {

        new->opts.gss_client_identity = strdup(src->opts.gss_client_identity);

        if (new->opts.gss_client_identity == NULL) {

            ssh_free(new);

            return -1;

        }

    }

    memcpy(new->opts.options_seen, src->opts.options_seen,

           sizeof(new->opts.options_seen));

    new->opts.fd                    = src->opts.fd;

    new->opts.port                  = src->opts.port;

    new->opts.timeout               = src->opts.timeout;

    new->opts.timeout_usec          = src->opts.timeout_usec;

    new->opts.compressionlevel      = src->opts.compressionlevel;

    new->opts.StrictHostKeyChecking = src->opts.StrictHostKeyChecking;

    new->opts.gss_delegate_creds    = src->opts.gss_delegate_creds;

    new->opts.flags                 = src->opts.flags;

    new->opts.nodelay               = src->opts.nodelay;

    new->opts.config_processed      = src->opts.config_processed;

    new->common.log_verbosity       = src->common.log_verbosity;

    new->common.callbacks           = src->common.callbacks;

    *dest = new;

    return 0;

}

int ssh_options_set_algo(ssh_session session,

                         enum ssh_kex_types_e algo,

                         const char *list)

{

    char *p = NULL;

    if (ssh_fips_mode()) {

        p = ssh_keep_fips_algos(algo, list);

    } else {

        p = ssh_keep_known_algos(algo, list);

    }

    if (p == NULL) {

        ssh_set_error(session, SSH_REQUEST_DENIED,

                "Setting method: no allowed algorithm for method \"%s\" (%s)",

                ssh_kex_get_description(algo), list);

        return -1;

    }

    SAFE_FREE(session->opts.wanted_methods[algo]);

    session->opts.wanted_methods[algo] = p;

    return 0;

}

/**

 * @brief This function can set all possible ssh options.

 *

 * @param  session An allocated SSH session structure.

 *

 * @param  type The option type to set. This could be one of the

 *              following:

 *

 *              - SSH_OPTIONS_HOST:

 *                The hostname or ip address to connect to (const char *).

 *

 *              - SSH_OPTIONS_PORT:

 *                The port to connect to (unsigned int *).

 *

 *              - SSH_OPTIONS_PORT_STR:

 *                The port to connect to (const char *).

 *

 *              - SSH_OPTIONS_FD:

 *                The file descriptor to use (socket_t).\n

 *                \n

 *                If you wish to open the socket yourself for a reason

 *                or another, set the file descriptor. Don't forget to

 *                set the hostname as the hostname is used as a key in

 *                the known_host mechanism.

 *

 *              - SSH_OPTIONS_BINDADDR:

 *                The address to bind the client to (const char *).

 *

 *              - SSH_OPTIONS_USER:

 *                The username for authentication (const char *).\n

 *                \n

 *                If the value is NULL, the username is set to the

 *                default username.

 *

 *              - SSH_OPTIONS_SSH_DIR:

 *                Set the ssh directory (const char *,format string).\n

 *                \n

 *                If the value is NULL, the directory is set to the

 *                default ssh directory.\n

 *                \n

 *                The ssh directory is used for files like known_hosts

 *                and identity (private and public key). It may include

 *                "%s" which will be replaced by the user home

 *                directory.

 *

 *              - SSH_OPTIONS_KNOWNHOSTS:

 *                Set the known hosts file name (const char *,format string).\n

 *                \n

 *                If the value is NULL, the directory is set to the

 *                default known hosts file, normally

 *                ~/.ssh/known_hosts.\n

 *                \n

 *                The known hosts file is used to certify remote hosts

 *                are genuine. It may include "%d" which will be

 *                replaced by the user home directory.

 *

 *              - SSH_OPTIONS_GLOBAL_KNOWNHOSTS:

 *                Set the global known hosts file name (const char *,format string).\n

 *                \n

 *                If the value is NULL, the directory is set to the

 *                default global known hosts file, normally

 *                /etc/ssh/ssh_known_hosts.\n

 *                \n

 *                The known hosts file is used to certify remote hosts

 *                are genuine.

 *

 *              - SSH_OPTIONS_ADD_IDENTITY (or SSH_OPTIONS_IDENTITY):

 *                Add a new identity file (const char *, format string) to

 *                the identity list.\n

 *                \n

 *                By default identity, id_dsa and id_rsa are checked.\n

 *                \n

 *                The identity used to authenticate with public key will be

 *                prepended to the list.

 *                It may include "%s" which will be replaced by the

 *                user home directory.

 *

 *              - SSH_OPTIONS_TIMEOUT:

 *                Set a timeout for the connection in seconds (long).

 *

 *              - SSH_OPTIONS_TIMEOUT_USEC:

 *                Set a timeout for the connection in micro seconds

 *                        (long).

 *

 *              - SSH_OPTIONS_SSH1:

 *                Deprecated

 *

 *              - SSH_OPTIONS_SSH2:

 *                Unused

 *

 *              - SSH_OPTIONS_LOG_VERBOSITY:

 *                Set the session logging verbosity (int).\n

 *                \n

 *                The verbosity of the messages. Every log smaller or

 *                equal to verbosity will be shown.

 *                - SSH_LOG_NOLOG: No logging

 *                - SSH_LOG_WARNING: Only warnings

 *                - SSH_LOG_PROTOCOL: High level protocol information

 *                - SSH_LOG_PACKET: Lower level protocol infomations, packet level

 *                - SSH_LOG_FUNCTIONS: Every function path

 *

 *              - SSH_OPTIONS_LOG_VERBOSITY_STR:

 *                Set the session logging verbosity via a

 *                string that will be converted to a numerical

 *                value (e.g. "3") and interpreted according

 *                to the values of

 *                SSH_OPTIONS_LOG_VERBOSITY above (const

 *                char *).

 *

 *              - SSH_OPTIONS_CIPHERS_C_S:

 *                Set the symmetric cipher client to server (const char *,

 *                comma-separated list).

 *

 *              - SSH_OPTIONS_CIPHERS_S_C:

 *                Set the symmetric cipher server to client (const char *,

 *                comma-separated list).

 *

 *              - SSH_OPTIONS_KEY_EXCHANGE:

 *                Set the key exchange method to be used (const char *,

 *                comma-separated list). ex:

 *                "ecdh-sha2-nistp256,diffie-hellman-group14-sha1,diffie-hellman-group1-sha1"

 *

 *              - SSH_OPTIONS_HMAC_C_S:

 *                Set the Message Authentication Code algorithm client to server

 *                (const char *, comma-separated list).

 *

 *              - SSH_OPTIONS_HMAC_S_C:

 *                Set the Message Authentication Code algorithm server to client

 *                (const char *, comma-separated list).

 *

 *              - SSH_OPTIONS_HOSTKEYS:

 *                Set the preferred server host key types (const char *,

 *                comma-separated list). ex:

 *                "ssh-rsa,ssh-dss,ecdh-sha2-nistp256"

 *

 *              - SSH_OPTIONS_PUBLICKEY_ACCEPTED_TYPES:

 *                Set the preferred public key algorithms to be used for

 *                authentication (const char *, comma-separated list). ex:

 *                "ssh-rsa,rsa-sha2-256,ssh-dss,ecdh-sha2-nistp256"

 *

 *              - SSH_OPTIONS_COMPRESSION_C_S:

 *                Set the compression to use for client to server

 *                communication (const char *, "yes", "no" or a specific

 *                algorithm name if needed ("zlib","zlib@openssh.com","none").

 *

 *              - SSH_OPTIONS_COMPRESSION_S_C:

 *                Set the compression to use for server to client

 *                communication (const char *, "yes", "no" or a specific

 *                algorithm name if needed ("zlib","zlib@openssh.com","none").

 *

 *              - SSH_OPTIONS_COMPRESSION:

 *                Set the compression to use for both directions

 *                communication (const char *, "yes", "no" or a specific

 *                algorithm name if needed ("zlib","zlib@openssh.com","none").

 *

 *              - SSH_OPTIONS_COMPRESSION_LEVEL:

 *                Set the compression level to use for zlib functions. (int,

 *                value from 1 to 9, 9 being the most efficient but slower).

 *

 *              - SSH_OPTIONS_STRICTHOSTKEYCHECK:

 *                Set the parameter StrictHostKeyChecking to avoid

 *                asking about a fingerprint (int, 0 = false).

 *

 *              - SSH_OPTIONS_PROXYCOMMAND:

 *                Set the command to be executed in order to connect to

 *                server (const char *).

 *

 *              - SSH_OPTIONS_GSSAPI_SERVER_IDENTITY

 *                Set it to specify the GSSAPI server identity that libssh

 *                should expect when connecting to the server (const char *).

 *

 *              - SSH_OPTIONS_GSSAPI_CLIENT_IDENTITY

 *                Set it to specify the GSSAPI client identity that libssh

 *                should expect when connecting to the server (const char *).

 *

 *              - SSH_OPTIONS_GSSAPI_DELEGATE_CREDENTIALS

 *                Set it to specify that GSSAPI should delegate credentials

 *                to the server (int, 0 = false).

 *

 *              - SSH_OPTIONS_PASSWORD_AUTH

 *                Set it if password authentication should be used

 *                in ssh_userauth_auto_pubkey(). (int, 0=false).

 *                Currently without effect (ssh_userauth_auto_pubkey doesn't use

 *                password authentication).

 *

 *              - SSH_OPTIONS_PUBKEY_AUTH

 *                Set it if pubkey authentication should be used

 *                in ssh_userauth_auto_pubkey(). (int, 0=false).

 *

 *              - SSH_OPTIONS_KBDINT_AUTH

 *                Set it if keyboard-interactive authentication should be used

 *                in ssh_userauth_auto_pubkey(). (int, 0=false).

 *                Currently without effect (ssh_userauth_auto_pubkey doesn't use

 *                keyboard-interactive authentication).

 *

 *              - SSH_OPTIONS_GSSAPI_AUTH

 *                Set it if gssapi authentication should be used

 *                in ssh_userauth_auto_pubkey(). (int, 0=false).

 *                Currently without effect (ssh_userauth_auto_pubkey doesn't use

 *                gssapi authentication).

 *

 *              - SSH_OPTIONS_NODELAY

 *                Set it to disable Nagle's Algorithm (TCP_NODELAY) on the

 *                session socket. (int, 0=false)

 *

 *              - SSH_OPTIONS_PROCESS_CONFIG

 *                Set it to false to disable automatic processing of per-user

 *                and system-wide OpenSSH configuration files. LibSSH

 *                automatically uses these configuration files unless

 *                you provide it with this option or with different file (bool).

 *

 *              - SSH_OPTIONS_REKEY_DATA

 *                Set the data limit that can be transferred with a single

 *                key in bytes. RFC 4253 Section 9 recommends 1GB of data, while

 *                RFC 4344 provides more specific restrictions, that are applied

 *                automatically. When specified, the lower value will be used.

 *                (uint64_t, 0=default)

 *

 *              - SSH_OPTIONS_REKEY_TIME

 *                Set the time limit for a session before intializing a rekey

 *                in seconds. RFC 4253 Section 9 recommends one hour.

 *                (uint32_t, 0=off)

 *

 * @param  value The value to set. This is a generic pointer and the

 *               datatype which is used should be set according to the

 *               type set.

 *

 * @return       0 on success, < 0 on error.

 */

int ssh_options_set(ssh_session session, enum ssh_options_e type,

    const void *value) {

    const char *v;

    char *p, *q;

    long int i;

    unsigned int u;

    int rc;

    if (session == NULL) {

        return -1;

    }

    switch (type) {

        case SSH_OPTIONS_HOST:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                q = strdup(value);

                if (q == NULL) {

                    ssh_set_error_oom(session);

                    return -1;

                }

                p = strchr(q, '@');

                SAFE_FREE(session->opts.host);

                if (p) {

                    *p = '\0';

                    session->opts.host = strdup(p + 1);

                    if (session->opts.host == NULL) {

                        SAFE_FREE(q);

                        ssh_set_error_oom(session);

                        return -1;

                    }

                    SAFE_FREE(session->opts.username);

                    session->opts.username = strdup(q);

                    SAFE_FREE(q);

                    if (session->opts.username == NULL) {

                        ssh_set_error_oom(session);

                        return -1;

                    }

                } else {

                    session->opts.host = q;

                }

            }

            break;

        case SSH_OPTIONS_PORT:

            if (value == NULL) {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                int *x = (int *) value;

                if (*x <= 0) {

                    ssh_set_error_invalid(session);

                    return -1;

                }

                session->opts.port = *x & 0xffffU;

            }

            break;

        case SSH_OPTIONS_PORT_STR:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                q = strdup(v);

                if (q == NULL) {

                    ssh_set_error_oom(session);

                    return -1;

                }

                i = strtol(q, &p, 10);

                if (q == p) {

                    SAFE_FREE(q);

                }

                SAFE_FREE(q);

                if (i <= 0) {

                    ssh_set_error_invalid(session);

                    return -1;

                }

                session->opts.port = i & 0xffffU;

            }

            break;

        case SSH_OPTIONS_FD:

            if (value == NULL) {

                session->opts.fd = SSH_INVALID_SOCKET;

                ssh_set_error_invalid(session);

                return -1;

            } else {

                socket_t *x = (socket_t *) value;

                if (*x < 0) {

                    session->opts.fd = SSH_INVALID_SOCKET;

                    ssh_set_error_invalid(session);

                    return -1;

                }

                session->opts.fd = *x & 0xffff;

            }

            break;

        case SSH_OPTIONS_BINDADDR:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            }

            q = strdup(v);

            if (q == NULL) {

                return -1;

            }

            SAFE_FREE(session->opts.bindaddr);

            session->opts.bindaddr = q;

            break;

        case SSH_OPTIONS_USER:

            v = value;

            SAFE_FREE(session->opts.username);

            if (v == NULL) {

                q = ssh_get_local_username();

                if (q == NULL) {

                    ssh_set_error_oom(session);

                    return -1;

                }

                session->opts.username = q;

            } else if (v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else { /* username provided */

                session->opts.username = strdup(value);

                if (session->opts.username == NULL) {

                    ssh_set_error_oom(session);

                    return -1;

                }

            }

            break;

        case SSH_OPTIONS_SSH_DIR:

            v = value;

            SAFE_FREE(session->opts.sshdir);

            if (v == NULL) {

                session->opts.sshdir = ssh_path_expand_tilde("~/.ssh");

                if (session->opts.sshdir == NULL) {

                    return -1;

                }

            } else if (v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                session->opts.sshdir = ssh_path_expand_tilde(v);

                if (session->opts.sshdir == NULL) {

                    ssh_set_error_oom(session);

                    return -1;

                }

            }

            break;

        case SSH_OPTIONS_IDENTITY:

        case SSH_OPTIONS_ADD_IDENTITY:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            }

            q = strdup(v);

            if (q == NULL) {

                return -1;

            }

            rc = ssh_list_prepend(session->opts.identity, q);

            if (rc < 0) {

                free(q);

                return -1;

            }

            break;

        case SSH_OPTIONS_KNOWNHOSTS:

            v = value;

            SAFE_FREE(session->opts.knownhosts);

            if (v == NULL) {

                /* The default value will be set by the ssh_options_apply() */

            } else if (v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                session->opts.knownhosts = strdup(v);

                if (session->opts.knownhosts == NULL) {

                    ssh_set_error_oom(session);

                    return -1;

                }

            }

            break;

        case SSH_OPTIONS_GLOBAL_KNOWNHOSTS:

            v = value;

            SAFE_FREE(session->opts.global_knownhosts);

            if (v == NULL) {

                session->opts.global_knownhosts =

                    strdup("/etc/ssh/ssh_known_hosts");

                if (session->opts.global_knownhosts == NULL) {

                    ssh_set_error_oom(session);

                    return -1;

                }

            } else if (v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                session->opts.global_knownhosts = strdup(v);

                if (session->opts.global_knownhosts == NULL) {

                    ssh_set_error_oom(session);

                    return -1;

                }

            }

            break;

        case SSH_OPTIONS_TIMEOUT:

            if (value == NULL) {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                long *x = (long *) value;

                if (*x < 0) {

                    ssh_set_error_invalid(session);

                    return -1;

                }

                session->opts.timeout = *x & 0xffffffffU;

            }

            break;

        case SSH_OPTIONS_TIMEOUT_USEC:

            if (value == NULL) {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                long *x = (long *) value;

                if (*x < 0) {

                    ssh_set_error_invalid(session);

                    return -1;

                }

                session->opts.timeout_usec = *x & 0xffffffffU;

            }

            break;

        case SSH_OPTIONS_SSH1:

            break;

        case SSH_OPTIONS_SSH2:

            break;

        case SSH_OPTIONS_LOG_VERBOSITY:

            if (value == NULL) {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                int *x = (int *) value;

                if (*x < 0) {

                    ssh_set_error_invalid(session);

                    return -1;

                }

                session->common.log_verbosity = *x & 0xffffU;

                ssh_set_log_level(*x & 0xffffU);

            }

            break;

        case SSH_OPTIONS_LOG_VERBOSITY_STR:

            v = value;

            if (v == NULL || v[0] == '\0') {

                session->common.log_verbosity = 0;

                ssh_set_error_invalid(session);

                return -1;

            } else {

                q = strdup(v);

                if (q == NULL) {

                    ssh_set_error_oom(session);

                    return -1;

                }

                i = strtol(q, &p, 10);

                if (q == p) {

                    SAFE_FREE(q);

                }

                SAFE_FREE(q);

                if (i < 0) {

                    ssh_set_error_invalid(session);

                    return -1;

                }

                session->common.log_verbosity = i & 0xffffU;

                ssh_set_log_level(i & 0xffffU);

            }

            break;

        case SSH_OPTIONS_CIPHERS_C_S:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                if (ssh_options_set_algo(session, SSH_CRYPT_C_S, v) < 0)

                    return -1;

            }

            break;

        case SSH_OPTIONS_CIPHERS_S_C:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                if (ssh_options_set_algo(session, SSH_CRYPT_S_C, v) < 0)

                    return -1;

            }

            break;

        case SSH_OPTIONS_KEY_EXCHANGE:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                if (ssh_options_set_algo(session, SSH_KEX, v) < 0)

                    return -1;

            }

            break;

        case SSH_OPTIONS_HOSTKEYS:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                if (ssh_options_set_algo(session, SSH_HOSTKEYS, v) < 0)

                    return -1;

            }

            break;

        case SSH_OPTIONS_PUBLICKEY_ACCEPTED_TYPES:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                if (ssh_fips_mode()) {

                    p = ssh_keep_fips_algos(SSH_HOSTKEYS, v);

                } else {

                    p = ssh_keep_known_algos(SSH_HOSTKEYS, v);

                }

                if (p == NULL) {

                    ssh_set_error(session, SSH_REQUEST_DENIED,

                        "Setting method: no known public key algorithm (%s)",

                         v);

                    return -1;

                }

                SAFE_FREE(session->opts.pubkey_accepted_types);

                session->opts.pubkey_accepted_types = p;

            }

            break;

        case SSH_OPTIONS_HMAC_C_S:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                if (ssh_options_set_algo(session, SSH_MAC_C_S, v) < 0)

                    return -1;

            }

            break;

         case SSH_OPTIONS_HMAC_S_C:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                if (ssh_options_set_algo(session, SSH_MAC_S_C, v) < 0)

                    return -1;

            }

            break;

        case SSH_OPTIONS_COMPRESSION_C_S:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                if (strcasecmp(value,"yes")==0){

                    if(ssh_options_set_algo(session,SSH_COMP_C_S,"zlib@openssh.com,zlib") < 0)

                        return -1;

                } else if (strcasecmp(value,"no")==0){

                    if(ssh_options_set_algo(session,SSH_COMP_C_S,"none") < 0)

                        return -1;

                } else {

                    if (ssh_options_set_algo(session, SSH_COMP_C_S, v) < 0)

                        return -1;

                }

            }

            break;

        case SSH_OPTIONS_COMPRESSION_S_C:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;

            } else {

                if (strcasecmp(value,"yes")==0){

                    if(ssh_options_set_algo(session,SSH_COMP_S_C,"zlib@openssh.com,zlib") < 0)

                        return -1;

                } else if (strcasecmp(value,"no")==0){

                    if(ssh_options_set_algo(session,SSH_COMP_S_C,"none") < 0)

                        return -1;

                } else {

                    if (ssh_options_set_algo(session, SSH_COMP_S_C, v) < 0)

                        return -1;

                }

            }

            break;

        case SSH_OPTIONS_COMPRESSION:

            v = value;

            if (v == NULL || v[0] == '\0') {

                ssh_set_error_invalid(session);

                return -1;