ports/libssh
ports/libssh
1
1
Форкнуть 0
Код Релизы 1 Активность

Merge branch 'master' of git://git.libssh.org/projects/libssh/libssh

Просмотр исходного кода
Этот коммит содержится в:
Aris Adamantiadis 2009-10-05 10:01:24 +02:00
родитель a3a7f17d0f 60d6954b75
Коммит 40778d4ba9
24 изменённых файлов: 679 добавлений и 955 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

10
CMakeLists.txt
Просмотреть файл

@ -69,11 +69,13 @@ include_directories(${CMAKE_SOURCE_DIR}/include)
if (UNIX AND NOT WIN32)
add_subdirectory(examples)
if (WITH_SFTP AND WITH_SERVER)
if (WITH_SFTP)
add_executable(samplessh sample.c)
add_executable(samplesshd samplesshd.c)
target_link_libraries(samplessh ${LIBSSH_SHARED_LIBRARY})
endif (WITH_SFTP)
if (WITH_SERVER)
add_executable(samplesshd samplesshd.c)
target_link_libraries(samplesshd ${LIBSSH_SHARED_LIBRARY})
endif (WITH_SFTP AND WITH_SERVER)
endif (WITH_SERVER)
endif (UNIX AND NOT WIN32)

3
ConfigureChecks.cmake
Просмотреть файл

@ -39,8 +39,10 @@ endif (WIN32)
set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIRS})
check_include_file(openssl/aes.h HAVE_OPENSSL_AES_H)
set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIRS})
check_include_file(openssl/blowfish.h HAVE_OPENSSL_BLOWFISH_H)
set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIRS})
check_include_file(openssl/des.h HAVE_OPENSSL_DES_H)
@ -75,6 +77,7 @@ if (UNIX)
check_function_exists(cfmakeraw HAVE_CFMAKERAW)
check_function_exists(regcomp HAVE_REGCOMP)
endif (UNIX)
set(LIBSSH_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} CACHE INTERNAL "libssh required system libraries")
# LIBRARIES

54
cmake/Modules/DefineCompilerFlags.cmake
Просмотреть файл

@ -13,31 +13,6 @@ if (UNIX AND NOT WIN32)
add_definitions(-fPIC)
endif (WITH_FPIC)
if (CMAKE_SIZEOF_VOID_P MATCHES "8")
# with large file support
execute_process(
COMMAND
getconf LFS64_CFLAGS
OUTPUT_VARIABLE
_lfs_CFLAGS
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
)
else (CMAKE_SIZEOF_VOID_P MATCHES "8")
# with large file support
execute_process(
COMMAND
getconf LFS_CFLAGS
OUTPUT_VARIABLE
_lfs_CFLAGS
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
)
string(REGEX REPLACE "[\r\n]" " " "${_lfs_CFLAGS}" "${${_lfs_CFLAGS}}")
add_definitions(${_lfs_CFLAGS})
endif (CMAKE_SIZEOF_VOID_P MATCHES "8")
check_c_compiler_flag("-fstack-protector" WITH_STACK_PROTECTOR)
if (WITH_STACK_PROTECTOR)
add_definitions(-fstack-protector)
@ -48,9 +23,34 @@ if (UNIX AND NOT WIN32)
add_definitions(-D_FORTIFY_SOURCE=2)
endif (WITH_FORTIFY_SOURCE)
# Set linker flags
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--as-needed")
endif (CMAKE_COMPILER_IS_GNUCC)
if (CMAKE_SIZEOF_VOID_P MATCHES "8")
# with large file support
execute_process(
COMMAND
getconf LFS64_CFLAGS
OUTPUT_VARIABLE
_lfs_CFLAGS
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
)
else (CMAKE_SIZEOF_VOID_P MATCHES "8")
# with large file support
execute_process(
COMMAND
getconf LFS_CFLAGS
OUTPUT_VARIABLE
_lfs_CFLAGS
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
)
endif (CMAKE_SIZEOF_VOID_P MATCHES "8")
if (_lfs_CFLAGS)
string(REGEX REPLACE "[\r\n]" " " "${_lfs_CFLAGS}" "${${_lfs_CFLAGS}}")
add_definitions(${_lfs_CFLAGS})
endif (_lfs_CFLAGS)
endif (UNIX AND NOT WIN32)
# suppress warning about "deprecated" functions

18
examples/connect_ssh.c
Просмотреть файл

@ -23,24 +23,24 @@ clients must be made or how a client should react.
ssh_session connect_ssh(const char *host, const char *user,int verbosity){
ssh_session session;
ssh_options options;
int auth=0;
options=ssh_options_new();
session=ssh_new();
if (session == NULL) {
return NULL;
}
if(user != NULL){
if (ssh_options_set_username(options,user) < 0) {
ssh_options_free(options);
if (ssh_options_set(session, SSH_OPTIONS_USER, user) < 0) {
ssh_disconnect(session);
return NULL;
}
}
if (ssh_options_set_host(options,host) < 0) {
ssh_options_free(options);
if (ssh_options_set(session, SSH_OPTIONS_HOST, host) < 0) {
return NULL;
}
ssh_options_set_log_verbosity(options,verbosity);
session=ssh_new();
ssh_set_options(session,options);
ssh_options_set(session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
if(ssh_connect(session)){
fprintf(stderr,"Connection failed : %s\n",ssh_get_error(session));
ssh_disconnect(session);

9
include/libssh/callback.h
Просмотреть файл

@ -54,6 +54,7 @@ typedef void (*ssh_log_callback) (ssh_session session, int priority,
* connection */
typedef void (*ssh_status_callback) (ssh_session session, float status,
void *userdata);
struct ssh_callbacks_struct {
/** size of this structure. internal, shoud be set with ssh_callbacks_init()*/
size_t size;
@ -81,12 +82,12 @@ typedef struct ssh_callbacks_struct * ssh_callbacks;
p->size=sizeof(*p); \
} while(0);
LIBSSH_API int ssh_options_set_auth_callback(ssh_options opt, ssh_auth_callback cb,
LIBSSH_API int ssh_set_auth_callback(ssh_session session, ssh_auth_callback cb,
void *userdata);
LIBSSH_API int ssh_options_set_log_function(ssh_options opt,
LIBSSH_API int ssh_set_log_callback(ssh_session session,
ssh_log_callback cb, void *userdata);
LIBSSH_API int ssh_options_set_status_callback(ssh_options opt, void (*callback)
(void *arg, float status), void *arg);
LIBSSH_API int ssh_set_status_callback(ssh_session session, void (*callback)
(void *arg, float status), void *arg);
#ifdef __cplusplus
}

42
include/libssh/libssh.h
Просмотреть файл

@ -94,6 +94,12 @@
#define PRINTF_ATTRIBUTE(a,b)
#endif /* __GNUC__ */
#ifdef __GNUC__
#define SSH_DEPRECATED __attribute__ ((deprecated))
#else
#define SSH_DEPRECATED
#endif
#ifdef __cplusplus
extern "C" {
#endif
@ -108,14 +114,14 @@ typedef struct ssh_agent_struct AGENT;
#endif
typedef struct ssh_message_struct SSH_MESSAGE;
typedef struct ssh_options_struct SSH_OPTIONS;
typedef struct ssh_session_struct SSH_OPTIONS;
typedef struct ssh_session_struct SSH_SESSION;
typedef struct ssh_agent_struct* ssh_agent;
typedef struct ssh_buffer_struct* ssh_buffer;
typedef struct ssh_channel_struct* ssh_channel;
typedef struct ssh_message_struct *ssh_message;
typedef struct ssh_options_struct* ssh_options;
typedef struct ssh_session_struct* ssh_options;
typedef struct ssh_private_key_struct* ssh_private_key;
typedef struct ssh_public_key_struct* ssh_public_key;
typedef struct ssh_scp_struct* ssh_scp;
@ -267,14 +273,7 @@ enum ssh_options_e {
SSH_OPTIONS_CIPHERS_C_S,
SSH_OPTIONS_CIPHERS_S_C,
SSH_OPTIONS_COMPRESSION_C_S,
SSH_OPTIONS_COMPRESSION_S_C,
SSH_OPTIONS_SERVER_BINDADDR,
SSH_OPTIONS_SERVER_BINDPORT,
SSH_OPTIONS_SERVER_HOSTKEY,
SSH_OPTIONS_SERVER_DSAKEY,
SSH_OPTIONS_SERVER_RSAKEY,
SSH_OPTIONS_SERVER_BANNER,
SSH_OPTIONS_COMPRESSION_S_C
};
enum {
@ -383,30 +382,13 @@ LIBSSH_API int ssh_message_subtype(ssh_message msg);
LIBSSH_API int ssh_message_type(ssh_message msg);
LIBSSH_API int ssh_mkdir (const char *pathname, mode_t mode);
LIBSSH_API ssh_session ssh_new(void);
LIBSSH_API ssh_options ssh_options_copy(ssh_options opt);
LIBSSH_API void ssh_options_free(ssh_options opt);
LIBSSH_API ssh_options ssh_options_new(void);
LIBSSH_API int ssh_options_allow_ssh1(ssh_options opt, int allow);
LIBSSH_API int ssh_options_allow_ssh2(ssh_options opt, int allow);
LIBSSH_API int ssh_options_copy(ssh_session src, ssh_session *dest);
LIBSSH_API int ssh_options_getopt(ssh_options options, int *argcptr, char **argv);
LIBSSH_API int ssh_options_parse_config(ssh_options opt, const char *filename);
LIBSSH_API int ssh_options_set(ssh_options opt, enum ssh_options_e type,
LIBSSH_API int ssh_options_set(ssh_session session, enum ssh_options_e type,
const void *value);
LIBSSH_API int ssh_options_set_banner(ssh_options opt, const char *banner);
LIBSSH_API int ssh_options_set_bind(ssh_options opt, const char *bindaddr, int port);
LIBSSH_API int ssh_options_set_dsa_server_key(ssh_options opt, const char *dsakey);
LIBSSH_API int ssh_options_set_fd(ssh_options opt, socket_t fd);
LIBSSH_API int ssh_options_set_host(ssh_options opt, const char *host);
LIBSSH_API int ssh_options_set_identity(ssh_options opt, const char *identity);
LIBSSH_API int ssh_options_set_log_verbosity(ssh_options opt, int verbosity);
LIBSSH_API int ssh_options_set_known_hosts_file(ssh_options opt, const char *dir);
LIBSSH_API int ssh_options_set_port(ssh_options opt, unsigned int port);
LIBSSH_API int ssh_options_set_rsa_server_key(ssh_options opt, const char *rsakey);
LIBSSH_API int ssh_options_set_ssh_dir(ssh_options opt, const char *dir);
LIBSSH_API int ssh_options_set_timeout(ssh_options opt, long seconds, long usec);
LIBSSH_API int ssh_options_set_username(ssh_options opt, const char *username);
LIBSSH_API int ssh_options_set_wanted_algos(ssh_options opt, int algo, const char *list);
LIBSSH_API void ssh_print_hexa(const char *descr, const unsigned char *what, size_t len);
LIBSSH_API int ssh_scp_accept_request(ssh_scp scp);
LIBSSH_API int ssh_scp_close(ssh_scp scp);

58
include/libssh/options.h
Просмотреть файл

@ -1,58 +0,0 @@
/*
* This file is part of the SSH Library
*
* Copyright (c) 2009 by Aris Adamantiadis
*
* 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.
*/
#ifndef OPTIONS_H_
#define OPTIONS_H_
#include "libssh/priv.h"
#include "libssh/callback.h"
struct ssh_options_struct {
struct error_struct error;
char *banner;
char *username;
char *host;
char *bindaddr;
int bindport;
char *identity;
char *ssh_dir;
char *known_hosts_file;
socket_t fd; /* specificaly wanted file descriptor, don't connect host */
int port;
char *wanted_methods[10]; /* the kex methods can be choosed. better use the kex fonctions to do that */
ssh_callbacks callbacks; /* Callbacks to user functions */
long timeout; /* seconds */
long timeout_usec;
int ssh2allowed;
int ssh1allowed;
char *dsakey;
char *rsakey; /* host key for server implementation */
int log_verbosity;
};
/* this function must be called when no specific username has been asked. it has to guess it */
int ssh_options_default_username(ssh_options opt);
int ssh_options_default_ssh_dir(ssh_options opt);
int ssh_options_default_known_hosts_file(ssh_options opt);
#endif /* OPTIONS_H_ */

24
include/libssh/priv.h
Просмотреть файл

@ -95,11 +95,21 @@ struct ssh_message_struct;
/* server data */
struct ssh_bind_struct {
struct error_struct error;
socket_t bindfd;
ssh_options options;
int blocking;
int toaccept;
struct error_struct error;
ssh_callbacks callbacks; /* Callbacks to user functions */
/* options */
char *wanted_methods[10];
char *banner;
char *dsakey;
char *rsakey;
char *bindaddr;
socket_t bindfd;
unsigned int bindport;
int blocking;
int toaccept;
};
@ -113,6 +123,8 @@ int ssh_config_parse_file(ssh_options opt, const char *filename);
/* errors.c */
void ssh_set_error(void *error, int code, const char *descr, ...) PRINTF_ATTRIBUTE(3, 4);
void ssh_set_error_oom(void *);
void ssh_set_error_invalid(void *, const char *);
/* in crypt.c */
uint32_t packet_decrypt_len(ssh_session session,char *crypted);
@ -124,7 +136,7 @@ int packet_hmac_verify(ssh_session session,ssh_buffer buffer,unsigned char *mac)
/* connect.c */
int ssh_regex_init(void);
void ssh_regex_finalize(void);
ssh_session ssh_session_new();
ssh_session ssh_session_new(void);
socket_t ssh_connect_host(ssh_session session, const char *host,const char
*bind_addr, int port, long timeout, long usec);

19
include/libssh/server.h
Просмотреть файл

@ -35,7 +35,17 @@
extern "C" {
#endif
enum ssh_bind_options_e {
SSH_BIND_OPTIONS_BINDADDR,
SSH_BIND_OPTIONS_BINDPORT,
SSH_BIND_OPTIONS_HOSTKEY,
SSH_BIND_OPTIONS_DSAKEY,
SSH_BIND_OPTIONS_RSAKEY,
SSH_BIND_OPTIONS_BANNER
};
typedef struct ssh_bind_struct SSH_BIND;
typedef struct ssh_bind_struct *ssh_bind;
/**
* @brief Creates a new SSH server bind.
@ -51,7 +61,8 @@ LIBSSH_API SSH_BIND *ssh_bind_new(void);
*
* @param options The option structure to set.
*/
LIBSSH_API void ssh_bind_set_options(SSH_BIND *ssh_bind, ssh_options options);
LIBSSH_API int ssh_bind_options_set(ssh_bind sshbind,
enum ssh_bind_options_e type, const void *value);
/**
* @brief Start listening to the socket.
@ -69,7 +80,7 @@ LIBSSH_API int ssh_bind_listen(SSH_BIND *ssh_bind);
*
* @param blocking Zero for nonblocking mode.
*/
LIBSSH_API void ssh_bind_set_blocking(SSH_BIND *ssh_bind, int blocking);
LIBSSH_API void ssh_bind_set_blocking(SSH_BIND *sshbind, int blocking);
/**
* @brief Recover the file descriptor from the session.
@ -78,7 +89,7 @@ LIBSSH_API void ssh_bind_set_blocking(SSH_BIND *ssh_bind, int blocking);
*
* @return The file descriptor.
*/
LIBSSH_API socket_t ssh_bind_get_fd(SSH_BIND *ssh_bind);
LIBSSH_API socket_t ssh_bind_get_fd(SSH_BIND *sshbind);
/**
* @brief Set the file descriptor for a session.
@ -87,7 +98,7 @@ LIBSSH_API socket_t ssh_bind_get_fd(SSH_BIND *ssh_bind);
*
* @param fd The file descriptor.
*/
LIBSSH_API void ssh_bind_set_fd(SSH_BIND *ssh_bind, socket_t fd);
LIBSSH_API void ssh_bind_set_fd(SSH_BIND *sshbind, socket_t fd);
/**
* @brief Allow the file descriptor to accept new sessions.

19
include/libssh/session.h
Просмотреть файл

@ -29,7 +29,6 @@ typedef struct ssh_kbdint_struct* ssh_kbdint;
struct ssh_session_struct {
struct error_struct error;
struct socket *socket;
ssh_options options;
char *serverbanner;
char *clientbanner;
int protoversion;
@ -93,6 +92,24 @@ struct ssh_session_struct {
int (*ssh_message_callback)( struct ssh_session_struct *session, ssh_message msg);
int log_verbosity; /*cached copy of the option structure */
int log_indent; /* indentation level in enter_function logs */
ssh_callbacks callbacks; /* Callbacks to user functions */
/* options */
char *username;
char *host;
char *bindaddr; /* TODO: check if needed */
char *xbanner; /* TODO: looks like it is not needed */
char *identity;
char *sshdir;
char *knownhosts;
char *wanted_methods[10];
unsigned long timeout; /* seconds */
unsigned long timeout_usec;
unsigned int port;
socket_t fd;
int ssh2;
int ssh1;
};
int ssh_handle_packets(ssh_session session);

47
libssh/auth.c
Просмотреть файл

@ -37,7 +37,6 @@
#include "libssh/keyfiles.h"
#include "libssh/packet.h"
#include "libssh/session.h"
#include "libssh/options.h"
#include "libssh/keys.h"
/** \defgroup ssh_auth SSH Authentication functions
@ -224,13 +223,13 @@ int ssh_userauth_none(ssh_session session, const char *username) {
#endif
if (username == NULL) {
if (session->options->username == NULL) {
if (ssh_options_set(session->options, SSH_OPTIONS_USER, NULL) < 0) {
if (session->username == NULL) {
if (ssh_options_set(session, SSH_OPTIONS_USER, NULL) < 0) {
leave_function();
return rc;
}
}
user = string_from_char(session->options->username);
user = string_from_char(session->username);
} else {
user = string_from_char(username);
}
@ -330,13 +329,13 @@ int ssh_userauth_offer_pubkey(ssh_session session, const char *username,
#endif
if (username == NULL) {
if (session->options->username == NULL) {
if (ssh_options_set(session->options, SSH_OPTIONS_USER, NULL) < 0) {
if (session->username == NULL) {
if (ssh_options_set(session, SSH_OPTIONS_USER, NULL) < 0) {
leave_function();
return rc;
}
}
user = string_from_char(session->options->username);
user = string_from_char(session->username);
} else {
user = string_from_char(username);
}
@ -442,13 +441,13 @@ int ssh_userauth_pubkey(ssh_session session, const char *username,
#endif
if (username == NULL) {
if (session->options->username == NULL) {
if (ssh_options_set(session->options, SSH_OPTIONS_USER, NULL) < 0) {
if (session->username == NULL) {
if (ssh_options_set(session, SSH_OPTIONS_USER, NULL) < 0) {
leave_function();
return rc;
}
}
user = string_from_char(session->options->username);
user = string_from_char(session->username);
} else {
user = string_from_char(username);
}
@ -560,13 +559,13 @@ int ssh_userauth_agent_pubkey(ssh_session session, const char *username,
}
if (username == NULL) {
if (session->options->username == NULL) {
if (ssh_options_set(session->options, SSH_OPTIONS_USER, NULL) < 0) {
if (session->username == NULL) {
if (ssh_options_set(session, SSH_OPTIONS_USER, NULL) < 0) {
leave_function();
return rc;
}
}
user = string_from_char(session->options->username);
user = string_from_char(session->username);
} else {
user = string_from_char(username);
}
@ -687,13 +686,13 @@ int ssh_userauth_password(ssh_session session, const char *username,
#endif
if (username == NULL) {
if (session->options->username == NULL) {
if (ssh_options_set(session->options, SSH_OPTIONS_USER, NULL) < 0) {
if (session->username == NULL) {
if (ssh_options_set(session, SSH_OPTIONS_USER, NULL) < 0) {
leave_function();
return rc;
}
}
user = string_from_char(session->options->username);
user = string_from_char(session->username);
} else {
user = string_from_char(username);
}
@ -903,18 +902,18 @@ int ssh_userauth_autopubkey(ssh_session session, const char *passphrase) {
#endif
size = ARRAY_SIZE(keytab);
if (session->options->identity) {
if (session->identity) {
ssh_log(session, SSH_LOG_RARE,
"Trying identity file %s\n", session->options->identity);
"Trying identity file %s\n", session->identity);
id = malloc(strlen(session->options->identity) + 1 + 4);
id = malloc(strlen(session->identity) + 1 + 4);
if (id == NULL) {
leave_function();
return SSH_AUTH_ERROR;
}
sprintf(id, "%s.pub", session->options->identity);
sprintf(id, "%s.pub", session->identity);
keytab[size - 1].privatekey = session->options->identity;
keytab[size - 1].privatekey = session->identity;
keytab[size - 1].publickey = id;
}
@ -1369,12 +1368,12 @@ int ssh_userauth_kbdint(ssh_session session, const char *user,
if (session->kbdint == NULL) {
/* first time we call. we must ask for a challenge */
if (user == NULL) {
if ((user = session->options->username) == NULL) {
if (ssh_options_set(session->options, SSH_OPTIONS_USER, NULL) < 0) {
if ((user = session->username) == NULL) {
if (ssh_options_set(session, SSH_OPTIONS_USER, NULL) < 0) {
leave_function();
return SSH_AUTH_ERROR;
} else {
user = session->options->username;
user = session->username;
}
}
}

9
libssh/auth1.c
Просмотреть файл

@ -21,6 +21,8 @@
* MA 02111-1307, USA.
*/
#include "config.h"
#include <string.h>
#include <stdlib.h>
@ -30,7 +32,6 @@
#include "libssh/packet.h"
#include "libssh/session.h"
#include "libssh/string.h"
#include "libssh/options.h"
#ifdef WITH_SSH1
static int wait_auth1_status(ssh_session session) {
@ -64,11 +65,11 @@ static int send_username(ssh_session session, const char *username) {
}
if (!username) {
if(!(username = session->options->username)) {
if (ssh_options_set(session->options, SSH_OPTIONS_USER, NULL) < 0) {
if(!(username = session->username)) {
if (ssh_options_set(session, SSH_OPTIONS_USER, NULL) < 0) {
return session->auth_service_asked = SSH_AUTH_ERROR;
} else {
username = session->options->username;
username = session->username;
}
}
}

46
libssh/client.c
Просмотреть файл

@ -35,12 +35,11 @@
#include "libssh/packet.h"
#include "libssh/socket.h"
#include "libssh/session.h"
#include "libssh/options.h"
#include "libssh/dh.h"
#define set_status(opt,status) do {\
if (opt->callbacks && opt->callbacks->connect_status_function) \
opt->callbacks->connect_status_function(opt->callbacks->userdata, status); \
#define set_status(session, status) do {\
if (session->callbacks && session->callbacks->connect_status_function) \
session->callbacks->connect_status_function(session->callbacks->userdata, status); \
} while (0)
/**
@ -169,8 +168,8 @@ int ssh_send_banner(ssh_session session, int server) {
banner = session->version == 1 ? CLIENTBANNER1 : CLIENTBANNER2;
if (session->options->banner) {
banner = session->options->banner;
if (session->xbanner) {
banner = session->xbanner;
}
if (server) {
@ -476,7 +475,6 @@ int ssh_service_request(ssh_session session, const char *service) {
* \see ssh_disconnect()
*/
int ssh_connect(ssh_session session) {
ssh_options options = session->options;
int ssh1 = 0;
int ssh2 = 0;
int fd = -1;
@ -486,12 +484,6 @@ int ssh_connect(ssh_session session) {
return SSH_ERROR;
}
if (session->options == NULL) {
ssh_set_error(session, SSH_FATAL, "No options set");
return SSH_ERROR;
}
options = session->options;
enter_function();
session->alive = 0;
@ -501,22 +493,22 @@ int ssh_connect(ssh_session session) {
leave_function();
return SSH_ERROR;
}
if (options->fd == -1 && options->host == NULL) {
if (session->fd == -1 && session->host == NULL) {
ssh_set_error(session, SSH_FATAL, "Hostname required");
leave_function();
return SSH_ERROR;
}
if (options->fd != -1) {
fd = options->fd;
if (session->fd != -1) {
fd = session->fd;
} else {
fd = ssh_connect_host(session, options->host, options->bindaddr,
options->port, options->timeout, options->timeout_usec);
fd = ssh_connect_host(session, session->host, session->bindaddr,
session->port, session->timeout, session->timeout_usec);
}
if (fd < 0) {
leave_function();
return SSH_ERROR;
}
set_status(options, 0.2);
set_status(session, 0.2);
ssh_socket_set_fd(session->socket, fd);
@ -528,7 +520,7 @@ int ssh_connect(ssh_session session) {
leave_function();
return SSH_ERROR;
}
set_status(options, 0.4);
set_status(session, 0.4);
ssh_log(session, SSH_LOG_RARE,
"SSH server banner: %s", session->serverbanner);
@ -542,9 +534,9 @@ int ssh_connect(ssh_session session) {
}
/* Here we decide which version of the protocol to use. */
if (ssh2 && options->ssh2allowed) {
if (ssh2 && session->ssh2) {
session->version = 2;
} else if(ssh1 && options->ssh1allowed) {
} else if(ssh1 && session->ssh1) {
session->version = 1;
} else {
ssh_set_error(session, SSH_FATAL,
@ -563,7 +555,7 @@ int ssh_connect(ssh_session session) {
leave_function();
return SSH_ERROR;
}
set_status(options, 0.5);
set_status(session, 0.5);
switch (session->version) {
case 2:
@ -573,7 +565,7 @@ int ssh_connect(ssh_session session) {
leave_function();
return SSH_ERROR;
}
set_status(options,0.6);
set_status(session,0.6);
ssh_list_kex(session, &session->server_kex);
if (set_kex(session) < 0) {
@ -588,7 +580,7 @@ int ssh_connect(ssh_session session) {
leave_function();
return SSH_ERROR;
}
set_status(options,0.8);
set_status(session,0.8);
if (dh_handshake(session) < 0) {
ssh_socket_close(session->socket);
@ -596,7 +588,7 @@ int ssh_connect(ssh_session session) {
leave_function();
return SSH_ERROR;
}
set_status(options,1.0);
set_status(session,1.0);
session->connected = 1;
break;
@ -607,7 +599,7 @@ int ssh_connect(ssh_session session) {
leave_function();
return SSH_ERROR;
}
set_status(options,0.6);
set_status(session,0.6);
session->connected = 1;
break;

42
libssh/config.c
Просмотреть файл

@ -26,7 +26,7 @@
#include <string.h>
#include "libssh/priv.h"
#include "libssh/options.h"
#include "libssh/session.h"
enum ssh_config_opcode_e {
SOC_UNSUPPORTED = -1,
@ -150,7 +150,7 @@ static int ssh_config_get_yesno(char **str, int notfound) {
return notfound;
}
static int ssh_config_parse_line(ssh_options opt, const char *line,
static int ssh_config_parse_line(ssh_session session, const char *line,
unsigned int count, int *parsing) {
enum ssh_config_opcode_e opcode;
const char *p;
@ -186,7 +186,7 @@ static int ssh_config_parse_line(ssh_options opt, const char *line,
*parsing = 0;
for (p = ssh_config_get_str(&s, NULL); p && *p;
p = ssh_config_get_str(&s, NULL)) {
if (match_hostname(opt->host, p, strlen(p))) {
if (match_hostname(session->host, p, strlen(p))) {
*parsing = 1;
}
}
@ -194,43 +194,43 @@ static int ssh_config_parse_line(ssh_options opt, const char *line,
case SOC_HOSTNAME:
p = ssh_config_get_str(&s, NULL);
if (p && *parsing) {
ssh_options_set(opt, SSH_OPTIONS_HOST, p);
ssh_options_set(session, SSH_OPTIONS_HOST, p);
}
break;
case SOC_PORT:
p = ssh_config_get_str(&s, NULL);
if (p && *parsing) {
ssh_options_set(opt, SSH_OPTIONS_PORT_STR, p);
ssh_options_set(session, SSH_OPTIONS_PORT_STR, p);
}
break;
case SOC_USERNAME:
p = ssh_config_get_str(&s, NULL);
if (p && *parsing) {
ssh_options_set(opt, SSH_OPTIONS_USER, p);
ssh_options_set(session, SSH_OPTIONS_USER, p);
}
break;
case SOC_IDENTITY:
p = ssh_config_get_str(&s, NULL);
if (p && *parsing) {
ssh_options_set(opt, SSH_OPTIONS_IDENTITY, p);
ssh_options_set(session, SSH_OPTIONS_IDENTITY, p);
}
break;
case SOC_CIPHERS:
p = ssh_config_get_str(&s, NULL);
if (p && *parsing) {
ssh_options_set(opt, SSH_OPTIONS_CIPHERS_C_S, p);
ssh_options_set(opt, SSH_OPTIONS_CIPHERS_S_C, p);
ssh_options_set(session, SSH_OPTIONS_CIPHERS_C_S, p);
ssh_options_set(session, SSH_OPTIONS_CIPHERS_S_C, p);
}
break;
case SOC_COMPRESSION:
i = ssh_config_get_yesno(&s, -1);
if (i >= 0 && *parsing) {
if (i) {
ssh_options_set(opt, SSH_OPTIONS_COMPRESSION_C_S, "zlib");
ssh_options_set(opt, SSH_OPTIONS_COMPRESSION_S_C, "zlib");
ssh_options_set(session, SSH_OPTIONS_COMPRESSION_C_S, "zlib");
ssh_options_set(session, SSH_OPTIONS_COMPRESSION_S_C, "zlib");
} else {
ssh_options_set(opt, SSH_OPTIONS_COMPRESSION_C_S, "none");
ssh_options_set(opt, SSH_OPTIONS_COMPRESSION_S_C, "none");
ssh_options_set(session, SSH_OPTIONS_COMPRESSION_C_S, "none");
ssh_options_set(session, SSH_OPTIONS_COMPRESSION_S_C, "none");
}
}
break;
@ -244,18 +244,18 @@ static int ssh_config_parse_line(ssh_options opt, const char *line,
return -1;
}
i = 0;
ssh_options_set(opt, SSH_OPTIONS_SSH1, &i);
ssh_options_set(opt, SSH_OPTIONS_SSH2, &i);
ssh_options_set(session, SSH_OPTIONS_SSH1, &i);
ssh_options_set(session, SSH_OPTIONS_SSH2, &i);
for (a = strtok(b, ","); a; a = strtok(NULL, ",")) {
switch (atoi(a)) {
case 1:
i = 1;
ssh_options_set(opt, SSH_OPTIONS_SSH1, &i);
ssh_options_set(session, SSH_OPTIONS_SSH1, &i);
break;
case 2:
i = 1;
ssh_options_set(opt, SSH_OPTIONS_SSH2, &i);
ssh_options_set(session, SSH_OPTIONS_SSH2, &i);
break;
default:
break;
@ -267,7 +267,7 @@ static int ssh_config_parse_line(ssh_options opt, const char *line,
case SOC_TIMEOUT:
i = ssh_config_get_int(&s, -1);
if (i >= 0 && *parsing) {
ssh_options_set(opt, SSH_OPTIONS_TIMEOUT, &i);
ssh_options_set(session, SSH_OPTIONS_TIMEOUT, &i);
}
break;
case SOC_UNSUPPORTED:
@ -285,7 +285,7 @@ static int ssh_config_parse_line(ssh_options opt, const char *line,
}
/* ssh_config_parse_file */
int ssh_config_parse_file(ssh_options opt, const char *filename) {
int ssh_config_parse_file(ssh_session session, const char *filename) {
char line[1024] = {0};
unsigned int count = 0;
FILE *f;
@ -295,14 +295,14 @@ int ssh_config_parse_file(ssh_options opt, const char *filename) {
return -1;
}
if (opt->log_verbosity) {
if (session->log_verbosity) {
fprintf(stderr, "Reading configuration data from %s\n", filename);
}
parsing = 1;
while (fgets(line, sizeof(line), f)) {
count++;
if (ssh_config_parse_line(opt, line, count, &parsing) < 0) {
if (ssh_config_parse_line(session, line, count, &parsing) < 0) {
fclose(f);
return -1;
}

7
libssh/dh.c
Просмотреть файл

@ -53,7 +53,6 @@
#include "libssh/crypto.h"
#include "libssh/buffer.h"
#include "libssh/session.h"
#include "libssh/options.h"
#include "libssh/keys.h"
#include "libssh/dh.h"
@ -1006,11 +1005,11 @@ int signature_verify(ssh_session session, ssh_string signature) {
return -1;
}
if (session->options->wanted_methods[SSH_HOSTKEYS]) {
if(!match(session->options->wanted_methods[SSH_HOSTKEYS],pubkey->type_c)) {
if (session->wanted_methods[SSH_HOSTKEYS]) {
if(!match(session->wanted_methods[SSH_HOSTKEYS],pubkey->type_c)) {
ssh_set_error(session, SSH_FATAL,
"Public key from server (%s) doesn't match user preference (%s)",
pubkey->type_c, session->options->wanted_methods[SSH_HOSTKEYS]);
pubkey->type_c, session->wanted_methods[SSH_HOSTKEYS]);
publickey_free(pubkey);
leave_function();
return -1;

31
libssh/error.c
Просмотреть файл

@ -41,7 +41,7 @@
*
* @brief Registers an error with a description.
*
* @param error The class of error.
* @param error The place to store the error.
*
* @param code The class of error.
*
@ -58,6 +58,35 @@ void ssh_set_error(void *error, int code, const char *descr, ...) {
err->error_code = code;
}
/**
* @internal
*
* @brief Registers an out of memory error
*
* @param error The place to store the error.
*
*/
void ssh_set_error_oom(void *error) {
struct error_struct *err = error;
strcpy(err->error_buffer, "Out of memory");
err->error_code = SSH_FATAL;
}
/**
* @internal
*
* @brief Registers an invalid argument error
*
* @param error The place to store the error.
*
* @param function The function the error happened in.
*
*/
void ssh_set_error_invalid(void *error, const char *function) {
ssh_set_error(error, SSH_FATAL, "Invalid argument in %s", function);
}
/**
* @brief Retrieve the error text message from the last error.
*

4
libssh/kex.c
Просмотреть файл

@ -38,7 +38,6 @@
#include "libssh/packet.h"
#include "libssh/session.h"
#include "libssh/wrapper.h"
#include "libssh/options.h"
#include "libssh/keys.h"
#include "libssh/dh.h"
@ -339,7 +338,6 @@ void ssh_list_kex(ssh_session session, KEX *kex) {
int set_kex(ssh_session session){
KEX *server = &session->server_kex;
KEX *client=&session->client_kex;
ssh_options options=session->options;
int i;
const char *wanted;
enter_function();
@ -352,7 +350,7 @@ int set_kex(ssh_session session){
}
memset(client->methods,0,10*sizeof(char **));
for (i=0;i<10;i++){
if(!(wanted=options->wanted_methods[i]))
if(!(wanted=session->wanted_methods[i]))
wanted=default_methods[i];
client->methods[i]=ssh_find_matching(server->methods[i],wanted);
if(!client->methods[i] && i < SSH_LANG_C_S){

43
libssh/keyfiles.c
Просмотреть файл

@ -42,7 +42,6 @@
#include "libssh/keyfiles.h"
#include "libssh/session.h"
#include "libssh/wrapper.h"
#include "libssh/options.h"
#include "libssh/misc.h"
#include "libssh/keys.h"
@ -599,9 +598,9 @@ static int pem_get_password(char *buf, int size, int rwflag, void *userdata) {
ssh_log(session, SSH_LOG_RARE,
"Trying to call external authentication function");
if (session && session->options->callbacks->auth_function) {
if (session->options->callbacks->auth_function("Passphrase for private key:", buf, size, 0, 0,
session->options->callbacks->userdata) < 0) {
if (session && session->callbacks->auth_function) {
if (session->callbacks->auth_function("Passphrase for private key:", buf, size, 0, 0,
session->callbacks->userdata) < 0) {
return 0;
}
@ -649,13 +648,13 @@ ssh_private_key privatekey_from_file(ssh_session session, const char *filename,
ssh_log(session, SSH_LOG_RARE, "Trying to read %s, passphase=%s, authcb=%s",
filename, passphrase ? "true" : "false",
session->options->callbacks->auth_function ? "true" : "false");
session->callbacks->auth_function ? "true" : "false");
switch (type) {
case TYPE_DSS:
if (passphrase == NULL) {
if (session->options->callbacks->auth_function) {
auth_cb = session->options->callbacks->auth_function;
auth_ud = session->options->callbacks->userdata;
if (session->callbacks->auth_function) {
auth_cb = session->callbacks->auth_function;
auth_ud = session->callbacks->userdata;
#ifdef HAVE_LIBGCRYPT
valid = read_dsa_privatekey(file, &dsa, auth_cb, auth_ud,
@ -693,9 +692,9 @@ ssh_private_key privatekey_from_file(ssh_session session, const char *filename,
break;
case TYPE_RSA:
if (passphrase == NULL) {
if (session->options->callbacks->auth_function) {
auth_cb = session->options->callbacks->auth_function;
auth_ud = session->options->callbacks->userdata;
if (session->callbacks->auth_function) {
auth_cb = session->callbacks->auth_function;
auth_ud = session->callbacks->userdata;
#ifdef HAVE_LIBGCRYPT
valid = read_rsa_privatekey(file, &rsa, auth_cb, auth_ud,
"Passphrase for private key:");
@ -1386,21 +1385,21 @@ int ssh_is_server_known(ssh_session session) {
enter_function();
if (ssh_options_set(session->options, SSH_OPTIONS_KNOWNHOSTS, NULL) < 0) {
if (ssh_options_set(session, SSH_OPTIONS_KNOWNHOSTS, NULL) < 0) {
ssh_set_error(session, SSH_REQUEST_DENIED,
"Can't find a known_hosts file");
leave_function();
return SSH_SERVER_FILE_NOT_FOUND;
}
if (session->options->host == NULL) {
if (session->host == NULL) {
ssh_set_error(session, SSH_FATAL,
"Can't verify host in known hosts if the hostname isn't known");
leave_function();
return SSH_SERVER_ERROR;
}
host = lowercase(session->options->host);
host = lowercase(session->host);
if (host == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space!");
leave_function();
@ -1409,7 +1408,7 @@ int ssh_is_server_known(ssh_session session) {
do {
tokens = ssh_get_knownhost_line(session, &file,
session->options->known_hosts_file, &type);
session->knownhosts, &type);
/* End of file, return the current state */
if (tokens == NULL) {
@ -1472,19 +1471,19 @@ int ssh_write_knownhost(ssh_session session) {
char *dir;
size_t len = 0;
if (ssh_options_set(session->options, SSH_OPTIONS_KNOWNHOSTS, NULL) < 0) {
if (ssh_options_set(session, SSH_OPTIONS_KNOWNHOSTS, NULL) < 0) {
ssh_set_error(session, SSH_FATAL, "Cannot find known_hosts file.");
return -1;
}
if (session->options->host == NULL) {
if (session->host == NULL) {
ssh_set_error(session, SSH_FATAL,
"Cannot write host in known hosts if the hostname is unknown");
return -1;
}
/* Check if ~/.ssh exists and create it if not */
dir = ssh_dirname(session->options->known_hosts_file);
dir = ssh_dirname(session->knownhosts);
if (dir == NULL) {
ssh_set_error(session, SSH_FATAL, "%s", strerror(errno));
return -1;
@ -1499,11 +1498,11 @@ int ssh_write_knownhost(ssh_session session) {
}
SAFE_FREE(dir);
file = fopen(session->options->known_hosts_file, "a");
file = fopen(session->knownhosts, "a");
if (file == NULL) {
ssh_set_error(session, SSH_FATAL,
"Couldn't open known_hosts file %s for appending: %s",
session->options->known_hosts_file, strerror(errno));
session->knownhosts, strerror(errno));
return -1;
}
@ -1583,7 +1582,7 @@ int ssh_write_knownhost(ssh_session session) {
snprintf(buffer, sizeof(buffer),
"%s %d %s %s\n",
session->options->host,
session->host,
rsa_size << 3,
e_string,
n_string);
@ -1608,7 +1607,7 @@ int ssh_write_knownhost(ssh_session session) {
snprintf(buffer, sizeof(buffer),
"%s %s %s\n",
session->options->host,
session->host,
session->current_crypto->server_pubkey_type,
pubkey_64);

7
libssh/log.c
Просмотреть файл

@ -27,7 +27,6 @@
#include "libssh/priv.h"
#include "libssh/session.h"
#include "libssh/options.h"
/**
* @defgroup ssh_log SSH Logging
@ -57,9 +56,9 @@ void ssh_log(ssh_session session, int verbosity, const char *format, ...) {
vsnprintf(buffer, sizeof(buffer), format, va);
va_end(va);
if (session->options->callbacks && session->options->callbacks->log_function) {
session->options->callbacks->log_function(session, verbosity, buffer,
session->options->callbacks->userdata);
if (session->callbacks && session->callbacks->log_function) {
session->callbacks->log_function(session, verbosity, buffer,
session->callbacks->userdata);
} else if (verbosity == SSH_LOG_FUNCTIONS) {
if (session->log_indent > 255) {
min = 255;

894
libssh/options.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

158
libssh/server.c
Просмотреть файл

@ -45,7 +45,6 @@
#include "libssh/socket.h"
#include "libssh/channels.h"
#include "libssh/session.h"
#include "libssh/options.h"
#include "libssh/misc.h"
#include "libssh/keys.h"
#include "libssh/dh.h"
@ -74,7 +73,7 @@ static char *hstrerror(int h_errno_val) {
#endif /* _WIN32 */
/* TODO FIXME: must use getaddrinfo */
static socket_t bind_socket(SSH_BIND *ssh_bind, const char *hostname,
static socket_t bind_socket(SSH_BIND *sshbind, const char *hostname,
int port) {
struct sockaddr_in myaddr;
struct hostent *hp=NULL;
@ -83,7 +82,7 @@ static socket_t bind_socket(SSH_BIND *ssh_bind, const char *hostname,
s = socket(PF_INET, SOCK_STREAM, 0);
if (s < 0) {
ssh_set_error(ssh_bind, SSH_FATAL, "%s", strerror(errno));
ssh_set_error(sshbind, SSH_FATAL, "%s", strerror(errno));
return -1;
}
@ -92,7 +91,7 @@ static socket_t bind_socket(SSH_BIND *ssh_bind, const char *hostname,
#endif
if (hp == NULL) {
ssh_set_error(ssh_bind, SSH_FATAL,
ssh_set_error(sshbind, SSH_FATAL,
"Resolving %s: %s", hostname, hstrerror(h_errno));
close(s);
return -1;
@ -104,14 +103,14 @@ static socket_t bind_socket(SSH_BIND *ssh_bind, const char *hostname,
myaddr.sin_port = htons(port);
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0) {
ssh_set_error(ssh_bind, SSH_FATAL,
ssh_set_error(sshbind, SSH_FATAL,
"Setting socket options failed: %s", hstrerror(h_errno));
close(s);
return -1;
}
if (bind(s, (struct sockaddr *) &myaddr, sizeof(myaddr)) < 0) {
ssh_set_error(ssh_bind, SSH_FATAL, "Binding to %s:%d: %s",
ssh_set_error(sshbind, SSH_FATAL, "Binding to %s:%d: %s",
hostname,
port,
strerror(errno));
@ -135,35 +134,27 @@ SSH_BIND *ssh_bind_new(void) {
return ptr;
}
void ssh_bind_set_options(SSH_BIND *ssh_bind, ssh_options options) {
ssh_bind->options = options;
}
int ssh_bind_listen(SSH_BIND *ssh_bind) {
int ssh_bind_listen(SSH_BIND *sshbind) {
const char *host;
int fd;
if (ssh_bind->options == NULL) {
return -1;
}
if (ssh_init() < 0) {
return -1;
}
host = ssh_bind->options->bindaddr;
host = sshbind->bindaddr;
if (host == NULL) {
host = "0.0.0.0";
}
fd = bind_socket(ssh_bind, host, ssh_bind->options->bindport);
fd = bind_socket(sshbind, host, sshbind->bindport);
if (fd < 0) {
return -1;
}
ssh_bind->bindfd = fd;
sshbind->bindfd = fd;
if (listen(fd, 10) < 0) {
ssh_set_error(ssh_bind, SSH_FATAL,
ssh_set_error(sshbind, SSH_FATAL,
"Listening to socket %d: %s",
fd, strerror(errno));
close(fd);
@ -173,58 +164,59 @@ int ssh_bind_listen(SSH_BIND *ssh_bind) {
return 0;
}
void ssh_bind_set_blocking(SSH_BIND *ssh_bind, int blocking) {
ssh_bind->blocking = blocking ? 1 : 0;
void ssh_bind_set_blocking(SSH_BIND *sshbind, int blocking) {
sshbind->blocking = blocking ? 1 : 0;
}
socket_t ssh_bind_get_fd(SSH_BIND *ssh_bind) {
return ssh_bind->bindfd;
socket_t ssh_bind_get_fd(SSH_BIND *sshbind) {
return sshbind->bindfd;
}
void ssh_bind_set_fd(SSH_BIND *ssh_bind, socket_t fd) {
ssh_bind->bindfd = fd;
void ssh_bind_set_fd(SSH_BIND *sshbind, socket_t fd) {
sshbind->bindfd = fd;
}
void ssh_bind_fd_toaccept(SSH_BIND *ssh_bind) {
ssh_bind->toaccept = 1;
void ssh_bind_fd_toaccept(SSH_BIND *sshbind) {
sshbind->toaccept = 1;
}
ssh_session ssh_bind_accept(SSH_BIND *ssh_bind) {
ssh_session ssh_bind_accept(SSH_BIND *sshbind) {
ssh_session session;
ssh_private_key dsa = NULL;
ssh_private_key rsa = NULL;
int fd = -1;
int i;
if (ssh_bind->bindfd < 0) {
ssh_set_error(ssh_bind, SSH_FATAL,
if (sshbind->bindfd < 0) {
ssh_set_error(sshbind, SSH_FATAL,
"Can't accept new clients on a not bound socket.");
return NULL;
}
if (ssh_bind->options->dsakey == NULL || ssh_bind->options->rsakey == NULL) {
ssh_set_error(ssh_bind, SSH_FATAL,
if (sshbind->dsakey == NULL || sshbind->rsakey == NULL) {
ssh_set_error(sshbind, SSH_FATAL,
"DSA or RSA host key file must be set before accept()");
return NULL;
}
if (ssh_bind->options->dsakey) {
dsa = _privatekey_from_file(ssh_bind, ssh_bind->options->dsakey, TYPE_DSS);
if (sshbind->dsakey) {
dsa = _privatekey_from_file(sshbind, sshbind->dsakey, TYPE_DSS);
if (dsa == NULL) {
return NULL;
}
}
if (ssh_bind->options->rsakey) {
rsa = _privatekey_from_file(ssh_bind, ssh_bind->options->rsakey, TYPE_RSA);
if (sshbind->rsakey) {
rsa = _privatekey_from_file(sshbind, sshbind->rsakey, TYPE_RSA);
if (rsa == NULL) {
privatekey_free(dsa);
return NULL;
}
}
fd = accept(ssh_bind->bindfd, NULL, NULL);
fd = accept(sshbind->bindfd, NULL, NULL);
if (fd < 0) {
ssh_set_error(ssh_bind, SSH_FATAL,
ssh_set_error(sshbind, SSH_FATAL,
"Accepting a new connection: %s",
strerror(errno));
privatekey_free(dsa);
@ -234,20 +226,41 @@ ssh_session ssh_bind_accept(SSH_BIND *ssh_bind) {
session = ssh_new();
if (session == NULL) {
ssh_set_error(ssh_bind, SSH_FATAL, "Not enough space");
ssh_set_error(sshbind, SSH_FATAL, "Not enough space");
privatekey_free(dsa);
privatekey_free(rsa);
return NULL;
}
session->server = 1;
session->version = 2;
session->options = ssh_options_copy(ssh_bind->options);
if (session->options == NULL) {
ssh_set_error(ssh_bind, SSH_FATAL, "No space left");
privatekey_free(dsa);
privatekey_free(rsa);
ssh_cleanup(session);
return NULL;
/* TODO: is wanted methods enough? */
#if 0
session->options = ssh_options_copy(sshbind->options);
#endif
/* copy options */
for (i = 0; i < 10; ++i) {
if (sshbind->wanted_methods[i]) {
session->wanted_methods[i] = strdup(sshbind->wanted_methods[i]);
if (session->wanted_methods[i] == NULL) {
privatekey_free(dsa);
privatekey_free(rsa);
ssh_cleanup(session);
return NULL;
}
}
}
if (sshbind->bindaddr == NULL)
session->bindaddr = NULL;
else {
session->bindaddr = strdup(sshbind->bindaddr);
if (session->bindaddr == NULL) {
privatekey_free(dsa);
privatekey_free(rsa);
ssh_cleanup(session);
return NULL;
}
}
session->log_verbosity = session->options->log_verbosity;
ssh_socket_free(session->socket);
@ -258,53 +271,74 @@ ssh_session ssh_bind_accept(SSH_BIND *ssh_bind) {
ssh_cleanup(session);
return NULL;
}
ssh_socket_set_fd(session->socket,fd);
ssh_socket_set_fd(session->socket, fd);
session->dsa_key = dsa;
session->rsa_key = rsa;
return session;
}
void ssh_bind_free(SSH_BIND *ssh_bind){
if (ssh_bind == NULL) {
void ssh_bind_free(SSH_BIND *sshbind){
int i;
if (sshbind == NULL) {
return;
}
if (ssh_bind->bindfd >= 0) {
close(ssh_bind->bindfd);
if (sshbind->bindfd >= 0) {
close(sshbind->bindfd);
}
ssh_bind->bindfd = -1;
if (ssh_bind->options) {
ssh_options_free(ssh_bind->options);
sshbind->bindfd = -1;
/* options */
SAFE_FREE(sshbind->banner);
SAFE_FREE(sshbind->dsakey);
SAFE_FREE(sshbind->rsakey);
SAFE_FREE(sshbind->bindaddr);
for (i = 0; i < 10; i++) {
if (sshbind->wanted_methods[i]) {
SAFE_FREE(sshbind->wanted_methods[i]);
}
}
SAFE_FREE(ssh_bind);
SAFE_FREE(sshbind);
}
extern char *supported_methods[];
/** @internal
* This functions sets the Key Exchange protocols to be accepted
* by the server. They depend on
* -What the user asked (via options)
* -What is available (keys)
* It should then accept the intersection of what the user asked
* and what is available, and return an error if nothing matches
* @bug To rewrite, it's broken !!
*/
static int server_set_kex(ssh_session session) {
static int server_set_kex(ssh_session session) {
KEX *server = &session->server_kex;
ssh_options options = session->options;
int i, j;
char *wanted;
ZERO_STRUCTP(server);
ssh_get_random(server->cookie, 16, 0);
#if 0
if (session->dsa_key != NULL && session->rsa_key != NULL) {
if (ssh_options_set(options, SSH_OPTIONS_SERVER_HOSTKEY,
if (ssh_bind_options_set(options, SSH_BIND_OPTIONS_HOSTKEY,
"ssh-dss,ssh-rsa") < 0) {
return -1;
}
} else if (session->dsa_key != NULL) {
if (ssh_options_set(options, SSH_OPTIONS_SERVER_HOSTKEY, "ssh-dss") < 0) {
if (ssh_bind_options_set(options, SSH_BIND_OPTIONS_HOSTKEY, "ssh-dss") < 0) {
return -1;
}
} else {
if (ssh_options_set(options, SSH_OPTIONS_SERVER_HOSTKEY, "ssh-rsa") < 0) {
if (ssh_bind_options_set(options, SSH_BIND_OPTIONS_HOSTKEY, "ssh-rsa") < 0) {
return -1;
}
}
#endif
server->methods = malloc(10 * sizeof(char **));
if (server->methods == NULL) {
@ -312,7 +346,7 @@ static int server_set_kex(ssh_session session) {
}
for (i = 0; i < 10; i++) {
if ((wanted = options->wanted_methods[i]) == NULL) {
if ((wanted = session->wanted_methods[i]) == NULL) {
wanted = supported_methods[i];
}
server->methods[i] = strdup(wanted);

42
libssh/session.c
Просмотреть файл

@ -27,12 +27,10 @@
#include "libssh/libssh.h"
#include "libssh/priv.h"
#include "libssh/server.h"
#include "libssh/callback.h"
#include "libssh/socket.h"
#include "libssh/agent.h"
#include "libssh/packet.h"
#include "libssh/session.h"
#include "libssh/options.h"
#include "libssh/misc.h"
#define FIRST_CHANNEL 42 // why not ? it helps to find bugs.
@ -60,17 +58,11 @@ ssh_session ssh_new(void) {
goto err;
}
session->maxchannel = FIRST_CHANNEL;
session->socket = ssh_socket_new(session);
if (session->socket == NULL) {
goto err;
}
session->alive = 0;
session->auth_methods = 0;
session->blocking = 1;
session->log_indent = 0;
session->out_buffer = buffer_new();
if (session->out_buffer == NULL) {
goto err;
@ -81,6 +73,22 @@ ssh_session ssh_new(void) {
goto err;
}
session->alive = 0;
session->auth_methods = 0;
session->blocking = 1;
session->log_indent = 0;
session->maxchannel = FIRST_CHANNEL;
/* options */
session->port = 22;
session->fd = -1;
session->ssh2 = 1;
#ifdef WITH_SSH1
session->ssh1 = 1;
#else
session->ssh1 = 0;
#endif
#ifndef _WIN32
session->agent = agent_new(session);
if (session->agent == NULL) {
@ -142,12 +150,23 @@ void ssh_cleanup(ssh_session session) {
}
ssh_list_free(session->ssh_message_list);
}
ssh_options_free(session->options);
/* options */
SAFE_FREE(session->username);
SAFE_FREE(session->host);
SAFE_FREE(session->identity);
SAFE_FREE(session->sshdir);
SAFE_FREE(session->knownhosts);
for (i = 0; i < 10; i++) {
if (session->wanted_methods[i]) {
SAFE_FREE(session->wanted_methods[i]);
}
}
/* burn connection, it could hang sensitive datas */
ZERO_STRUCTP(session);
SAFE_FREE(session);
/* FIXME: leave_function(); ??? */
}
/** \brief disconnect impolitely from remote host
@ -177,8 +196,7 @@ void ssh_set_options(ssh_session session, ssh_options options) {
return;
}
session->options = options;
session->log_verbosity = options->log_verbosity;
return;
}
/** \brief set the session in blocking/nonblocking mode

23
sample.c
Просмотреть файл

@ -502,7 +502,6 @@ static int auth_kbdint(ssh_session session){
int main(int argc, char **argv){
ssh_session session;
ssh_options options;
int auth=0;
char *password;
char *banner;
@ -512,30 +511,30 @@ int main(int argc, char **argv){
unsigned char *hash = NULL;
int hlen;
options=ssh_options_new();
if(ssh_options_getopt(options,&argc, argv)){
fprintf(stderr,"error parsing command line :%s\n",ssh_get_error(options));
usage();
session = ssh_new();
if(ssh_options_getopt(session, &argc, argv)) {
fprintf(stderr, "error parsing command line :%s\n",
ssh_get_error(session));
usage();
}
opts(argc,argv);
signal(SIGTERM, do_exit);
if (user) {
if (ssh_options_set(options, SSH_OPTIONS_USER, user) < 0) {
ssh_options_free(options);
if (ssh_options_set(session, SSH_OPTIONS_USER, user) < 0) {
ssh_disconnect(session);
return 1;
}
}
if (ssh_options_set(options, SSH_OPTIONS_HOST ,host) < 0) {
ssh_options_free(options);
if (ssh_options_set(session, SSH_OPTIONS_HOST ,host) < 0) {
ssh_disconnect(session);
return 1;
}
ssh_options_parse_config(options, NULL);
ssh_options_parse_config(session, NULL);
session=ssh_new();
ssh_set_options(session,options);
if(ssh_connect(session)){
fprintf(stderr,"Connection failed : %s\n",ssh_get_error(session));
ssh_disconnect(session);

25
samplesshd.c
Просмотреть файл

@ -25,11 +25,13 @@ MA 02111-1307, USA. */
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#ifndef KEYS_FOLDER
#ifdef _WIN32
#define KEYS_FOLDER
#else
#define KEYS_FOLDER "/etc/ssh/"
#endif
#endif
static int auth_password(char *user, char *password){
if(strcmp(user,"aris"))
@ -40,29 +42,28 @@ static int auth_password(char *user, char *password){
}
int main(int argc, char **argv){
ssh_options options=ssh_options_new();
ssh_session session;
SSH_BIND *ssh_bind;
ssh_bind ssh_bind_o;
ssh_message message;
ssh_channel chan=0;
ssh_buffer buf;
int auth=0;
int sftp=0;
int i;
ssh_options_getopt(options, &argc, argv);
ssh_options_set(options, SSH_OPTIONS_SERVER_DSAKEY, KEYS_FOLDER "ssh_host_dsa_key");
ssh_options_set(options, SSH_OPTIONS_SERVER_RSAKEY, KEYS_FOLDER "ssh_host_rsa_key");
ssh_bind_o=ssh_bind_new();
// ssh_options_getopt(options, &argc, argv);
ssh_bind_options_set(ssh_bind_o, SSH_BIND_OPTIONS_DSAKEY, KEYS_FOLDER "ssh_host_dsa_key");
ssh_bind_options_set(ssh_bind_o, SSH_BIND_OPTIONS_RSAKEY, KEYS_FOLDER "ssh_host_rsa_key");
ssh_bind=ssh_bind_new();
ssh_bind_set_options(ssh_bind,options);
if(ssh_bind_listen(ssh_bind)<0){
printf("Error listening to socket: %s\n",ssh_get_error(ssh_bind));
// ssh_bind_set_options(ssh_bind_o,options);
if(ssh_bind_listen(ssh_bind_o)<0){
printf("Error listening to socket: %s\n",ssh_get_error(ssh_bind_o));
return 1;
}
session=ssh_bind_accept(ssh_bind);
session=ssh_bind_accept(ssh_bind_o);
if(!session){
printf("error accepting a connection : %s\n",ssh_get_error(ssh_bind));
printf("error accepting a connection : %s\n",ssh_get_error(ssh_bind_o));
return 1;
}
printf("Socket connected: fd = %d\n", ssh_get_fd(session));
@ -153,7 +154,7 @@ int main(int argc, char **argv){
} while (i>0);
buffer_free(buf);
ssh_disconnect(session);
ssh_bind_free(ssh_bind);
ssh_bind_free(ssh_bind_o);
ssh_finalize();
return 0;
}