get rid of SSH_SESSION
Этот коммит содержится в:
родитель
ffed8b03bb
Коммит
9a8d4cd0fd
@ -302,7 +302,7 @@ LIBSSH_API ssh_session channel_get_session(ssh_channel channel);
|
||||
LIBSSH_API int channel_is_closed(ssh_channel channel);
|
||||
LIBSSH_API int channel_is_eof(ssh_channel channel);
|
||||
LIBSSH_API int channel_is_open(ssh_channel channel);
|
||||
LIBSSH_API ssh_channel channel_new(SSH_SESSION *session);
|
||||
LIBSSH_API ssh_channel channel_new(ssh_session session);
|
||||
LIBSSH_API int channel_open_forward(ssh_channel channel, const char *remotehost,
|
||||
int remoteport, const char *sourcehost, int localport);
|
||||
LIBSSH_API int channel_open_session(ssh_channel channel);
|
||||
@ -330,46 +330,46 @@ LIBSSH_API void channel_set_blocking(ssh_channel channel, int blocking);
|
||||
LIBSSH_API int channel_write(ssh_channel channel, const void *data, uint32_t len);
|
||||
|
||||
LIBSSH_API void privatekey_free(ssh_private_key prv);
|
||||
LIBSSH_API ssh_private_key privatekey_from_file(SSH_SESSION *session, const char *filename,
|
||||
LIBSSH_API ssh_private_key privatekey_from_file(ssh_session session, const char *filename,
|
||||
int type, const char *passphrase);
|
||||
LIBSSH_API void publickey_free(ssh_public_key key);
|
||||
LIBSSH_API ssh_string publickey_from_file(SSH_SESSION *session, const char *filename,
|
||||
LIBSSH_API ssh_string publickey_from_file(ssh_session session, const char *filename,
|
||||
int *type);
|
||||
LIBSSH_API ssh_public_key publickey_from_privatekey(ssh_private_key prv);
|
||||
LIBSSH_API ssh_string publickey_to_string(ssh_public_key key);
|
||||
|
||||
LIBSSH_API int ssh_auth_list(SSH_SESSION *session);
|
||||
LIBSSH_API int ssh_auth_list(ssh_session session);
|
||||
LIBSSH_API char *ssh_basename (const char *path);
|
||||
LIBSSH_API void ssh_clean_pubkey_hash(unsigned char **hash);
|
||||
LIBSSH_API int ssh_connect(SSH_SESSION *session);
|
||||
LIBSSH_API int ssh_connect(ssh_session session);
|
||||
LIBSSH_API const char *ssh_copyright(void);
|
||||
LIBSSH_API void ssh_disconnect(SSH_SESSION *session);
|
||||
LIBSSH_API void ssh_disconnect(ssh_session session);
|
||||
LIBSSH_API char *ssh_dirname (const char *path);
|
||||
LIBSSH_API int ssh_finalize(void);
|
||||
LIBSSH_API const char *ssh_get_disconnect_message(SSH_SESSION *session);
|
||||
LIBSSH_API const char *ssh_get_disconnect_message(ssh_session session);
|
||||
LIBSSH_API const char *ssh_get_error(void *error);
|
||||
LIBSSH_API int ssh_get_error_code(void *error);
|
||||
LIBSSH_API socket_t ssh_get_fd(SSH_SESSION *session);
|
||||
LIBSSH_API socket_t ssh_get_fd(ssh_session session);
|
||||
LIBSSH_API char *ssh_get_hexa(const unsigned char *what, size_t len);
|
||||
LIBSSH_API char *ssh_get_issue_banner(SSH_SESSION *session);
|
||||
LIBSSH_API char *ssh_get_issue_banner(ssh_session session);
|
||||
LIBSSH_API int ssh_get_openssh_version(ssh_session session);
|
||||
LIBSSH_API ssh_string ssh_get_pubkey(SSH_SESSION *session);
|
||||
LIBSSH_API int ssh_get_pubkey_hash(SSH_SESSION *session, unsigned char **hash);
|
||||
LIBSSH_API ssh_string ssh_get_pubkey(ssh_session session);
|
||||
LIBSSH_API int ssh_get_pubkey_hash(ssh_session session, unsigned char **hash);
|
||||
LIBSSH_API int ssh_get_random(void *where,int len,int strong);
|
||||
LIBSSH_API int ssh_get_version(SSH_SESSION *session);
|
||||
LIBSSH_API int ssh_get_status(SSH_SESSION *session);
|
||||
LIBSSH_API int ssh_get_version(ssh_session session);
|
||||
LIBSSH_API int ssh_get_status(ssh_session session);
|
||||
LIBSSH_API int ssh_init(void);
|
||||
LIBSSH_API int ssh_is_server_known(SSH_SESSION *session);
|
||||
LIBSSH_API void ssh_log(SSH_SESSION *session, int prioriry, const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
|
||||
LIBSSH_API int ssh_is_server_known(ssh_session session);
|
||||
LIBSSH_API void ssh_log(ssh_session session, int prioriry, const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
|
||||
LIBSSH_API ssh_channel ssh_message_channel_request_open_reply_accept(SSH_MESSAGE *msg);
|
||||
LIBSSH_API int ssh_message_channel_request_reply_success(SSH_MESSAGE *msg);
|
||||
LIBSSH_API void ssh_message_free(SSH_MESSAGE *msg);
|
||||
LIBSSH_API SSH_MESSAGE *ssh_message_get(SSH_SESSION *session);
|
||||
LIBSSH_API SSH_MESSAGE *ssh_message_retrieve(SSH_SESSION *session, uint32_t packettype);
|
||||
LIBSSH_API SSH_MESSAGE *ssh_message_get(ssh_session session);
|
||||
LIBSSH_API SSH_MESSAGE *ssh_message_retrieve(ssh_session session, uint32_t packettype);
|
||||
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_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);
|
||||
@ -413,32 +413,32 @@ LIBSSH_API const char *ssh_scp_request_get_warning(ssh_scp scp);
|
||||
LIBSSH_API int ssh_scp_write(ssh_scp scp, const void *buffer, size_t len);
|
||||
LIBSSH_API int ssh_select(ssh_channel *channels, ssh_channel *outchannels, socket_t maxfd,
|
||||
fd_set *readfds, struct timeval *timeout);
|
||||
LIBSSH_API int ssh_service_request(SSH_SESSION *session, const char *service);
|
||||
LIBSSH_API void ssh_set_blocking(SSH_SESSION *session, int blocking);
|
||||
LIBSSH_API void ssh_set_fd_except(SSH_SESSION *session);
|
||||
LIBSSH_API void ssh_set_fd_toread(SSH_SESSION *session);
|
||||
LIBSSH_API void ssh_set_fd_towrite(SSH_SESSION *session);
|
||||
LIBSSH_API void ssh_set_options(SSH_SESSION *session, SSH_OPTIONS *options);
|
||||
LIBSSH_API void ssh_silent_disconnect(SSH_SESSION *session);
|
||||
LIBSSH_API int ssh_service_request(ssh_session session, const char *service);
|
||||
LIBSSH_API void ssh_set_blocking(ssh_session session, int blocking);
|
||||
LIBSSH_API void ssh_set_fd_except(ssh_session session);
|
||||
LIBSSH_API void ssh_set_fd_toread(ssh_session session);
|
||||
LIBSSH_API void ssh_set_fd_towrite(ssh_session session);
|
||||
LIBSSH_API void ssh_set_options(ssh_session session, SSH_OPTIONS *options);
|
||||
LIBSSH_API void ssh_silent_disconnect(ssh_session session);
|
||||
#ifndef _WIN32
|
||||
LIBSSH_API int ssh_userauth_agent_pubkey(SSH_SESSION *session, const char *username,
|
||||
LIBSSH_API int ssh_userauth_agent_pubkey(ssh_session session, const char *username,
|
||||
ssh_public_key publickey);
|
||||
#endif
|
||||
LIBSSH_API int ssh_userauth_autopubkey(SSH_SESSION *session, const char *passphrase);
|
||||
LIBSSH_API int ssh_userauth_kbdint(SSH_SESSION *session, const char *user, const char *submethods);
|
||||
LIBSSH_API const char *ssh_userauth_kbdint_getinstruction(SSH_SESSION *session);
|
||||
LIBSSH_API const char *ssh_userauth_kbdint_getname(SSH_SESSION *session);
|
||||
LIBSSH_API int ssh_userauth_kbdint_getnprompts(SSH_SESSION *session);
|
||||
LIBSSH_API const char *ssh_userauth_kbdint_getprompt(SSH_SESSION *session, unsigned int i, char *echo);
|
||||
LIBSSH_API int ssh_userauth_kbdint_setanswer(SSH_SESSION *session, unsigned int i,
|
||||
LIBSSH_API int ssh_userauth_autopubkey(ssh_session session, const char *passphrase);
|
||||
LIBSSH_API int ssh_userauth_kbdint(ssh_session session, const char *user, const char *submethods);
|
||||
LIBSSH_API const char *ssh_userauth_kbdint_getinstruction(ssh_session session);
|
||||
LIBSSH_API const char *ssh_userauth_kbdint_getname(ssh_session session);
|
||||
LIBSSH_API int ssh_userauth_kbdint_getnprompts(ssh_session session);
|
||||
LIBSSH_API const char *ssh_userauth_kbdint_getprompt(ssh_session session, unsigned int i, char *echo);
|
||||
LIBSSH_API int ssh_userauth_kbdint_setanswer(ssh_session session, unsigned int i,
|
||||
const char *answer);
|
||||
LIBSSH_API int ssh_userauth_list(SSH_SESSION *session, const char *username);
|
||||
LIBSSH_API int ssh_userauth_none(SSH_SESSION *session, const char *username);
|
||||
LIBSSH_API int ssh_userauth_offer_pubkey(SSH_SESSION *session, const char *username, int type, ssh_string publickey);
|
||||
LIBSSH_API int ssh_userauth_password(SSH_SESSION *session, const char *username, const char *password);
|
||||
LIBSSH_API int ssh_userauth_pubkey(SSH_SESSION *session, const char *username, ssh_string publickey, ssh_private_key privatekey);
|
||||
LIBSSH_API int ssh_userauth_list(ssh_session session, const char *username);
|
||||
LIBSSH_API int ssh_userauth_none(ssh_session session, const char *username);
|
||||
LIBSSH_API int ssh_userauth_offer_pubkey(ssh_session session, const char *username, int type, ssh_string publickey);
|
||||
LIBSSH_API int ssh_userauth_password(ssh_session session, const char *username, const char *password);
|
||||
LIBSSH_API int ssh_userauth_pubkey(ssh_session session, const char *username, ssh_string publickey, ssh_private_key privatekey);
|
||||
LIBSSH_API const char *ssh_version(int req_version);
|
||||
LIBSSH_API int ssh_write_knownhost(SSH_SESSION *session);
|
||||
LIBSSH_API int ssh_write_knownhost(ssh_session session);
|
||||
|
||||
LIBSSH_API void string_burn(ssh_string str);
|
||||
LIBSSH_API ssh_string string_copy(ssh_string str);
|
||||
|
@ -321,7 +321,7 @@ typedef struct ssh_crypto_struct {
|
||||
struct ssh_channel_struct {
|
||||
struct ssh_channel_struct *prev;
|
||||
struct ssh_channel_struct *next;
|
||||
SSH_SESSION *session; /* SSH_SESSION pointer */
|
||||
ssh_session session; /* SSH_SESSION pointer */
|
||||
uint32_t local_channel;
|
||||
uint32_t local_window;
|
||||
int local_eof;
|
||||
@ -513,7 +513,7 @@ struct ssh_channel_request {
|
||||
};
|
||||
|
||||
struct ssh_message_struct {
|
||||
SSH_SESSION *session;
|
||||
ssh_session session;
|
||||
int type;
|
||||
struct ssh_auth_request auth_request;
|
||||
struct ssh_channel_request_open channel_request_open;
|
||||
@ -601,7 +601,7 @@ int ssh_poll_ctx(SSH_POLL_CTX *ctx, int timeout);
|
||||
|
||||
struct socket;
|
||||
int ssh_socket_init(void);
|
||||
struct socket *ssh_socket_new(SSH_SESSION *session);
|
||||
struct socket *ssh_socket_new(ssh_session session);
|
||||
void ssh_socket_free(struct socket *s);
|
||||
void ssh_socket_set_fd(struct socket *s, socket_t fd);
|
||||
socket_t ssh_socket_get_fd(struct socket *s);
|
||||
@ -616,7 +616,7 @@ int ssh_socket_fd_isset(struct socket *s, fd_set *set);
|
||||
void ssh_socket_fd_set(struct socket *s, fd_set *set, int *fd_max);
|
||||
int ssh_socket_completeread(struct socket *s, void *buffer, uint32_t len);
|
||||
int ssh_socket_completewrite(struct socket *s, const void *buffer, uint32_t len);
|
||||
int ssh_socket_wait_for_data(struct socket *s, SSH_SESSION *session, uint32_t len);
|
||||
int ssh_socket_wait_for_data(struct socket *s, ssh_session session, uint32_t len);
|
||||
int ssh_socket_nonblocking_flush(struct socket *s);
|
||||
int ssh_socket_blocking_flush(struct socket *s);
|
||||
int ssh_socket_poll(struct socket *s, int *writeable, int *except);
|
||||
@ -628,12 +628,12 @@ int ssh_socket_data_available(struct socket *s);
|
||||
int ssh_socket_data_writable(struct socket *s);
|
||||
/* session.c */
|
||||
|
||||
void ssh_cleanup(SSH_SESSION *session);
|
||||
void ssh_cleanup(ssh_session session);
|
||||
|
||||
/* client.c */
|
||||
|
||||
int ssh_send_banner(SSH_SESSION *session, int is_server);
|
||||
char *ssh_get_banner(SSH_SESSION *session);
|
||||
int ssh_send_banner(ssh_session session, int is_server);
|
||||
char *ssh_get_banner(ssh_session session);
|
||||
|
||||
/* config.c */
|
||||
int ssh_config_parse_file(ssh_options opt, const char *filename);
|
||||
@ -644,103 +644,103 @@ void ssh_set_error(void *error, int code, const char *descr, ...) PRINTF_ATTRIBU
|
||||
/* in dh.c */
|
||||
/* DH key generation */
|
||||
void ssh_print_bignum(const char *which,bignum num);
|
||||
int dh_generate_e(SSH_SESSION *session);
|
||||
int dh_generate_f(SSH_SESSION *session);
|
||||
int dh_generate_x(SSH_SESSION *session);
|
||||
int dh_generate_y(SSH_SESSION *session);
|
||||
int dh_generate_e(ssh_session session);
|
||||
int dh_generate_f(ssh_session session);
|
||||
int dh_generate_x(ssh_session session);
|
||||
int dh_generate_y(ssh_session session);
|
||||
|
||||
int ssh_crypto_init(void);
|
||||
void ssh_crypto_finalize(void);
|
||||
|
||||
ssh_string dh_get_e(SSH_SESSION *session);
|
||||
ssh_string dh_get_f(SSH_SESSION *session);
|
||||
int dh_import_f(SSH_SESSION *session,ssh_string f_string);
|
||||
int dh_import_e(SSH_SESSION *session, ssh_string e_string);
|
||||
void dh_import_pubkey(SSH_SESSION *session,ssh_string pubkey_string);
|
||||
int dh_build_k(SSH_SESSION *session);
|
||||
int make_sessionid(SSH_SESSION *session);
|
||||
ssh_string dh_get_e(ssh_session session);
|
||||
ssh_string dh_get_f(ssh_session session);
|
||||
int dh_import_f(ssh_session session,ssh_string f_string);
|
||||
int dh_import_e(ssh_session session, ssh_string e_string);
|
||||
void dh_import_pubkey(ssh_session session,ssh_string pubkey_string);
|
||||
int dh_build_k(ssh_session session);
|
||||
int make_sessionid(ssh_session session);
|
||||
/* add data for the final cookie */
|
||||
int hashbufin_add_cookie(SSH_SESSION *session, unsigned char *cookie);
|
||||
int hashbufout_add_cookie(SSH_SESSION *session);
|
||||
int generate_session_keys(SSH_SESSION *session);
|
||||
int sig_verify(SSH_SESSION *session, ssh_public_key pubkey,
|
||||
int hashbufin_add_cookie(ssh_session session, unsigned char *cookie);
|
||||
int hashbufout_add_cookie(ssh_session session);
|
||||
int generate_session_keys(ssh_session session);
|
||||
int sig_verify(ssh_session session, ssh_public_key pubkey,
|
||||
SIGNATURE *signature, unsigned char *digest, int size);
|
||||
/* returns 1 if server signature ok, 0 otherwise. The NEXT crypto is checked, not the current one */
|
||||
int signature_verify(SSH_SESSION *session,ssh_string signature);
|
||||
int signature_verify(ssh_session session,ssh_string signature);
|
||||
bignum make_string_bn(ssh_string string);
|
||||
ssh_string make_bignum_string(bignum num);
|
||||
|
||||
/* in crypt.c */
|
||||
uint32_t packet_decrypt_len(SSH_SESSION *session,char *crypted);
|
||||
int packet_decrypt(SSH_SESSION *session, void *packet,unsigned int len);
|
||||
unsigned char *packet_encrypt(SSH_SESSION *session,void *packet,unsigned int len);
|
||||
uint32_t packet_decrypt_len(ssh_session session,char *crypted);
|
||||
int packet_decrypt(ssh_session session, void *packet,unsigned int len);
|
||||
unsigned char *packet_encrypt(ssh_session session,void *packet,unsigned int len);
|
||||
/* it returns the hmac buffer if exists*/
|
||||
int packet_hmac_verify(SSH_SESSION *session,ssh_buffer buffer,unsigned char *mac);
|
||||
int packet_hmac_verify(ssh_session session,ssh_buffer buffer,unsigned char *mac);
|
||||
|
||||
/* in packet.c */
|
||||
|
||||
void packet_parse(SSH_SESSION *session);
|
||||
int packet_send(SSH_SESSION *session);
|
||||
void packet_parse(ssh_session session);
|
||||
int packet_send(ssh_session session);
|
||||
|
||||
int packet_read(SSH_SESSION *session);
|
||||
int packet_translate(SSH_SESSION *session);
|
||||
int packet_wait(SSH_SESSION *session,int type,int blocking);
|
||||
int packet_flush(SSH_SESSION *session, int enforce_blocking);
|
||||
int packet_read(ssh_session session);
|
||||
int packet_translate(ssh_session session);
|
||||
int packet_wait(ssh_session session,int type,int blocking);
|
||||
int packet_flush(ssh_session session, int enforce_blocking);
|
||||
|
||||
/* connect.c */
|
||||
int ssh_regex_init(void);
|
||||
void ssh_regex_finalize(void);
|
||||
SSH_SESSION *ssh_session_new();
|
||||
socket_t ssh_connect_host(SSH_SESSION *session, const char *host,const char
|
||||
ssh_session ssh_session_new();
|
||||
socket_t ssh_connect_host(ssh_session session, const char *host,const char
|
||||
*bind_addr, int port, long timeout, long usec);
|
||||
|
||||
/* in kex.c */
|
||||
extern const char *ssh_kex_nums[];
|
||||
int ssh_send_kex(SSH_SESSION *session, int server_kex);
|
||||
void ssh_list_kex(SSH_SESSION *session, KEX *kex);
|
||||
int set_kex(SSH_SESSION *session);
|
||||
int ssh_get_kex(SSH_SESSION *session, int server_kex);
|
||||
int ssh_send_kex(ssh_session session, int server_kex);
|
||||
void ssh_list_kex(ssh_session session, KEX *kex);
|
||||
int set_kex(ssh_session session);
|
||||
int ssh_get_kex(ssh_session session, int server_kex);
|
||||
int verify_existing_algo(int algo, const char *name);
|
||||
char **space_tokenize(const char *chain);
|
||||
int ssh_get_kex1(SSH_SESSION *session);
|
||||
int ssh_get_kex1(ssh_session session);
|
||||
char *ssh_find_matching(const char *in_d, const char *what_d);
|
||||
|
||||
/* in keyfiles.c */
|
||||
|
||||
ssh_private_key _privatekey_from_file(void *session, const char *filename,
|
||||
int type);
|
||||
ssh_string try_publickey_from_file(SSH_SESSION *session,
|
||||
ssh_string try_publickey_from_file(ssh_session session,
|
||||
struct ssh_keys_struct keytab,
|
||||
char **privkeyfile, int *type);
|
||||
|
||||
/* in keys.c */
|
||||
const char *ssh_type_to_char(int type);
|
||||
int ssh_type_from_name(const char *name);
|
||||
ssh_buffer ssh_userauth_build_digest(SSH_SESSION *session, ssh_message msg, char *service);
|
||||
ssh_buffer ssh_userauth_build_digest(ssh_session session, ssh_message msg, char *service);
|
||||
|
||||
ssh_private_key privatekey_make_dss(SSH_SESSION *session, ssh_buffer buffer);
|
||||
ssh_private_key privatekey_make_rsa(SSH_SESSION *session, ssh_buffer buffer,
|
||||
ssh_private_key privatekey_make_dss(ssh_session session, ssh_buffer buffer);
|
||||
ssh_private_key privatekey_make_rsa(ssh_session session, ssh_buffer buffer,
|
||||
const char *type);
|
||||
ssh_private_key privatekey_from_string(SSH_SESSION *session, ssh_string privkey_s);
|
||||
ssh_private_key privatekey_from_string(ssh_session session, ssh_string privkey_s);
|
||||
|
||||
ssh_public_key publickey_make_dss(SSH_SESSION *session, ssh_buffer buffer);
|
||||
ssh_public_key publickey_make_rsa(SSH_SESSION *session, ssh_buffer buffer, int type);
|
||||
ssh_public_key publickey_from_string(SSH_SESSION *session, ssh_string pubkey_s);
|
||||
SIGNATURE *signature_from_string(SSH_SESSION *session, ssh_string signature,ssh_public_key pubkey,int needed_type);
|
||||
ssh_public_key publickey_make_dss(ssh_session session, ssh_buffer buffer);
|
||||
ssh_public_key publickey_make_rsa(ssh_session session, ssh_buffer buffer, int type);
|
||||
ssh_public_key publickey_from_string(ssh_session session, ssh_string pubkey_s);
|
||||
SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,ssh_public_key pubkey,int needed_type);
|
||||
void signature_free(SIGNATURE *sign);
|
||||
ssh_string ssh_do_sign_with_agent(struct ssh_session_struct *session,
|
||||
struct ssh_buffer_struct *buf, struct ssh_public_key_struct *publickey);
|
||||
ssh_string ssh_do_sign(SSH_SESSION *session,ssh_buffer sigbuf,
|
||||
ssh_string ssh_do_sign(ssh_session session,ssh_buffer sigbuf,
|
||||
ssh_private_key privatekey);
|
||||
ssh_string ssh_sign_session_id(SSH_SESSION *session, ssh_private_key privatekey);
|
||||
ssh_string ssh_encrypt_rsa1(SSH_SESSION *session, ssh_string data, ssh_public_key key);
|
||||
ssh_string ssh_sign_session_id(ssh_session session, ssh_private_key privatekey);
|
||||
ssh_string ssh_encrypt_rsa1(ssh_session session, ssh_string data, ssh_public_key key);
|
||||
/* channel.c */
|
||||
void channel_handle(SSH_SESSION *session, int type);
|
||||
ssh_channel channel_new(SSH_SESSION *session);
|
||||
void channel_handle(ssh_session session, int type);
|
||||
ssh_channel channel_new(ssh_session session);
|
||||
int channel_default_bufferize(ssh_channel channel, void *data, int len,
|
||||
int is_stderr);
|
||||
uint32_t ssh_channel_new_id(SSH_SESSION *session);
|
||||
ssh_channel ssh_channel_from_local(SSH_SESSION *session, uint32_t id);
|
||||
uint32_t ssh_channel_new_id(ssh_session session);
|
||||
ssh_channel ssh_channel_from_local(ssh_session session, uint32_t id);
|
||||
int channel_write_common(ssh_channel channel, const void *data,
|
||||
uint32_t len, int is_stderr);
|
||||
|
||||
@ -785,12 +785,12 @@ ssh_buffer base64_to_bin(const char *source);
|
||||
unsigned char *bin_to_base64(const unsigned char *source, int len);
|
||||
|
||||
/* gzip.c */
|
||||
int compress_buffer(SSH_SESSION *session,ssh_buffer buf);
|
||||
int decompress_buffer(SSH_SESSION *session,ssh_buffer buf, size_t maxlen);
|
||||
int compress_buffer(ssh_session session,ssh_buffer buf);
|
||||
int decompress_buffer(ssh_session session,ssh_buffer buf, size_t maxlen);
|
||||
|
||||
/* wrapper.c */
|
||||
int crypt_set_algorithms(SSH_SESSION *);
|
||||
int crypt_set_algorithms_server(SSH_SESSION *session);
|
||||
int crypt_set_algorithms(ssh_session );
|
||||
int crypt_set_algorithms_server(ssh_session session);
|
||||
CRYPTO *crypto_new(void);
|
||||
void crypto_free(CRYPTO *crypto);
|
||||
|
||||
@ -798,10 +798,10 @@ void crypto_free(CRYPTO *crypto);
|
||||
uint32_t ssh_crc32(const char *buf, uint32_t len);
|
||||
|
||||
/* auth1.c */
|
||||
int ssh_userauth1_none(SSH_SESSION *session, const char *username);
|
||||
int ssh_userauth1_offer_pubkey(SSH_SESSION *session, const char *username,
|
||||
int ssh_userauth1_none(ssh_session session, const char *username);
|
||||
int ssh_userauth1_offer_pubkey(ssh_session session, const char *username,
|
||||
int type, ssh_string pubkey);
|
||||
int ssh_userauth1_password(SSH_SESSION *session, const char *username,
|
||||
int ssh_userauth1_password(ssh_session session, const char *username,
|
||||
const char *password);
|
||||
/* in misc.c */
|
||||
/* gets the user home dir. */
|
||||
@ -854,20 +854,20 @@ int channel_request_pty_size1(ssh_channel channel, const char *terminal,
|
||||
int channel_change_pty_size1(ssh_channel channel, int cols, int rows);
|
||||
int channel_request_shell1(ssh_channel channel);
|
||||
int channel_request_exec1(ssh_channel channel, const char *cmd);
|
||||
int channel_handle1(SSH_SESSION *session, int type);
|
||||
int channel_handle1(ssh_session session, int type);
|
||||
int channel_write1(ssh_channel channel, const void *data, int len);
|
||||
|
||||
/* session.c */
|
||||
|
||||
int ssh_handle_packets(SSH_SESSION *session);
|
||||
int ssh_handle_packets(ssh_session session);
|
||||
|
||||
/* match.c */
|
||||
int match_hostname(const char *host, const char *pattern, unsigned int len);
|
||||
|
||||
/* messages.c */
|
||||
|
||||
void message_handle(SSH_SESSION *session, uint32_t type);
|
||||
int ssh_execute_message_callbacks(SSH_SESSION *session);
|
||||
void message_handle(ssh_session session, uint32_t type);
|
||||
int ssh_execute_message_callbacks(ssh_session session);
|
||||
|
||||
/* scp.c */
|
||||
int ssh_scp_read_string(ssh_scp scp, char *buffer, size_t len);
|
||||
|
@ -103,7 +103,7 @@ LIBSSH_API void ssh_bind_fd_toaccept(SSH_BIND *ssh_bind);
|
||||
*
|
||||
* @return A newly allocated ssh session, NULL on error.
|
||||
*/
|
||||
LIBSSH_API SSH_SESSION *ssh_bind_accept(SSH_BIND *ssh_bind);
|
||||
LIBSSH_API ssh_session ssh_bind_accept(SSH_BIND *ssh_bind);
|
||||
|
||||
/**
|
||||
* @brief Free a ssh servers bind.
|
||||
@ -119,7 +119,7 @@ LIBSSH_API void ssh_bind_free(SSH_BIND *ssh_bind);
|
||||
*
|
||||
* @return 0 on success, < 0 on error.
|
||||
*/
|
||||
LIBSSH_API int ssh_accept(SSH_SESSION *session);
|
||||
LIBSSH_API int ssh_accept(ssh_session session);
|
||||
|
||||
LIBSSH_API int channel_write_stderr(ssh_channel channel, const void *data, uint32_t len);
|
||||
|
||||
@ -136,7 +136,7 @@ LIBSSH_API int ssh_message_auth_set_methods(SSH_MESSAGE *msg, int methods);
|
||||
LIBSSH_API int ssh_message_service_reply_success(SSH_MESSAGE *msg);
|
||||
LIBSSH_API char *ssh_message_service_service(SSH_MESSAGE *msg);
|
||||
|
||||
LIBSSH_API void ssh_set_message_callback(SSH_SESSION *session,
|
||||
LIBSSH_API void ssh_set_message_callback(ssh_session session,
|
||||
int(*ssh_message_callback)(ssh_session session, ssh_message msg));
|
||||
|
||||
LIBSSH_API char *ssh_message_channel_request_open_originator(SSH_MESSAGE *msg);
|
||||
|
@ -70,7 +70,7 @@ extern "C" {
|
||||
typedef struct sftp_ext_struct *sftp_ext;
|
||||
|
||||
typedef struct sftp_session_struct {
|
||||
SSH_SESSION *session;
|
||||
ssh_session session;
|
||||
ssh_channel channel;
|
||||
int server_version;
|
||||
int client_version;
|
||||
@ -194,7 +194,7 @@ typedef struct sftp_statvfs_struct {
|
||||
*
|
||||
* @return A new sftp session or NULL on error.
|
||||
*/
|
||||
LIBSSH_API SFTP_SESSION *sftp_new(SSH_SESSION *session);
|
||||
LIBSSH_API SFTP_SESSION *sftp_new(ssh_session session);
|
||||
|
||||
/**
|
||||
* @brief Close and deallocate a sftp session.
|
||||
@ -764,7 +764,7 @@ LIBSSH_API int sftp_server_version(SFTP_SESSION *sftp);
|
||||
*
|
||||
* @return A new sftp server session.
|
||||
*/
|
||||
LIBSSH_API SFTP_SESSION *sftp_server_new(SSH_SESSION *session, ssh_channel chan);
|
||||
LIBSSH_API SFTP_SESSION *sftp_server_new(ssh_session session, ssh_channel chan);
|
||||
|
||||
/**
|
||||
* @brief Intialize the sftp server.
|
||||
|
@ -160,7 +160,7 @@ void agent_free(ssh_agent agent) {
|
||||
}
|
||||
}
|
||||
|
||||
static int agent_connect(SSH_SESSION *session) {
|
||||
static int agent_connect(ssh_session session) {
|
||||
const char *auth_sock = NULL;
|
||||
|
||||
if (session == NULL || session->agent == NULL) {
|
||||
@ -475,7 +475,7 @@ error:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int agent_is_running(SSH_SESSION *session) {
|
||||
int agent_is_running(ssh_session session) {
|
||||
if (session == NULL || session->agent == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
@ -39,7 +39,7 @@
|
||||
/** \addtogroup ssh_auth
|
||||
* @{ */
|
||||
|
||||
static int ask_userauth(SSH_SESSION *session) {
|
||||
static int ask_userauth(ssh_session session) {
|
||||
int rc = 0;
|
||||
|
||||
enter_function();
|
||||
@ -56,7 +56,7 @@ static int ask_userauth(SSH_SESSION *session) {
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int wait_auth_status(SSH_SESSION *session, int kbdint) {
|
||||
static int wait_auth_status(ssh_session session, int kbdint) {
|
||||
char *auth_methods = NULL;
|
||||
ssh_string auth;
|
||||
int rc = SSH_AUTH_ERROR;
|
||||
@ -163,7 +163,7 @@ static int wait_auth_status(SSH_SESSION *session, int kbdint) {
|
||||
return rc;
|
||||
}
|
||||
|
||||
int ssh_auth_list(SSH_SESSION *session) {
|
||||
int ssh_auth_list(ssh_session session) {
|
||||
if (session == NULL) {
|
||||
return -1;
|
||||
}
|
||||
@ -171,7 +171,7 @@ int ssh_auth_list(SSH_SESSION *session) {
|
||||
return session->auth_methods;
|
||||
}
|
||||
|
||||
int ssh_userauth_list(SSH_SESSION *session, const char *username) {
|
||||
int ssh_userauth_list(ssh_session session, const char *username) {
|
||||
if (session == NULL || username == NULL) {
|
||||
return SSH_AUTH_ERROR;
|
||||
}
|
||||
@ -200,7 +200,7 @@ int ssh_userauth_list(SSH_SESSION *session, const char *username) {
|
||||
* have to use another method\n
|
||||
* SSH_AUTH_SUCCESS: Authentication success
|
||||
*/
|
||||
int ssh_userauth_none(SSH_SESSION *session, const char *username) {
|
||||
int ssh_userauth_none(ssh_session session, const char *username) {
|
||||
ssh_string user = NULL;
|
||||
ssh_string service = NULL;
|
||||
ssh_string method = NULL;
|
||||
@ -304,7 +304,7 @@ error:
|
||||
* @see privatekey_from_file()
|
||||
* @see ssh_userauth_pubkey()
|
||||
*/
|
||||
int ssh_userauth_offer_pubkey(SSH_SESSION *session, const char *username,
|
||||
int ssh_userauth_offer_pubkey(ssh_session session, const char *username,
|
||||
int type, ssh_string publickey) {
|
||||
ssh_string user = NULL;
|
||||
ssh_string service = NULL;
|
||||
@ -417,7 +417,7 @@ error:
|
||||
* @see privatekey_free()
|
||||
* @see ssh_userauth_offer_pubkey()
|
||||
*/
|
||||
int ssh_userauth_pubkey(SSH_SESSION *session, const char *username,
|
||||
int ssh_userauth_pubkey(ssh_session session, const char *username,
|
||||
ssh_string publickey, ssh_private_key privatekey) {
|
||||
ssh_string user = NULL;
|
||||
ssh_string service = NULL;
|
||||
@ -536,7 +536,7 @@ error:
|
||||
* @see privatekey_free()
|
||||
* @see ssh_userauth_offer_pubkey()
|
||||
*/
|
||||
int ssh_userauth_agent_pubkey(SSH_SESSION *session, const char *username,
|
||||
int ssh_userauth_agent_pubkey(ssh_session session, const char *username,
|
||||
ssh_public_key publickey) {
|
||||
ssh_string user = NULL;
|
||||
ssh_string service = NULL;
|
||||
@ -661,7 +661,7 @@ error:
|
||||
* @see ssh_userauth_kbdint()
|
||||
* @see BURN_STRING
|
||||
*/
|
||||
int ssh_userauth_password(SSH_SESSION *session, const char *username,
|
||||
int ssh_userauth_password(ssh_session session, const char *username,
|
||||
const char *password) {
|
||||
ssh_string user = NULL;
|
||||
ssh_string service = NULL;
|
||||
@ -808,7 +808,7 @@ static struct ssh_keys_struct keytab[] = {
|
||||
* @see ssh_userauth_password()
|
||||
* @see ssh_options_set()
|
||||
*/
|
||||
int ssh_userauth_autopubkey(SSH_SESSION *session, const char *passphrase) {
|
||||
int ssh_userauth_autopubkey(ssh_session session, const char *passphrase) {
|
||||
struct ssh_public_key_struct *publickey;
|
||||
ssh_string pubkey;
|
||||
ssh_private_key privkey;
|
||||
@ -1089,7 +1089,7 @@ static void kbdint_clean(ssh_kbdint kbd) {
|
||||
|
||||
/* this function sends the first packet as explained in section 3.1
|
||||
* of the draft */
|
||||
static int kbdauth_init(SSH_SESSION *session, const char *user,
|
||||
static int kbdauth_init(ssh_session session, const char *user,
|
||||
const char *submethods) {
|
||||
ssh_string usr = NULL;
|
||||
ssh_string sub = NULL;
|
||||
@ -1149,7 +1149,7 @@ error:
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int kbdauth_info_get(SSH_SESSION *session) {
|
||||
static int kbdauth_info_get(ssh_session session) {
|
||||
ssh_string name; /* name of the "asking" window showed to client */
|
||||
ssh_string instruction;
|
||||
ssh_string tmp;
|
||||
@ -1266,7 +1266,7 @@ static int kbdauth_info_get(SSH_SESSION *session) {
|
||||
}
|
||||
|
||||
/* sends challenge back to the server */
|
||||
static int kbdauth_send(SSH_SESSION *session) {
|
||||
static int kbdauth_send(ssh_session session) {
|
||||
ssh_string answer = NULL;
|
||||
int rc = SSH_AUTH_ERROR;
|
||||
uint32_t i;
|
||||
@ -1339,7 +1339,7 @@ error:
|
||||
* @see ssh_userauth_kbdint_getprompt()
|
||||
* @see ssh_userauth_kbdint_setanswer()
|
||||
*/
|
||||
int ssh_userauth_kbdint(SSH_SESSION *session, const char *user,
|
||||
int ssh_userauth_kbdint(ssh_session session, const char *user,
|
||||
const char *submethods) {
|
||||
int rc = SSH_AUTH_ERROR;
|
||||
|
||||
@ -1419,7 +1419,7 @@ int ssh_userauth_kbdint(SSH_SESSION *session, const char *user,
|
||||
*
|
||||
* @returns The number of prompts.
|
||||
*/
|
||||
int ssh_userauth_kbdint_getnprompts(SSH_SESSION *session) {
|
||||
int ssh_userauth_kbdint_getnprompts(ssh_session session) {
|
||||
return session->kbdint->nprompts;
|
||||
}
|
||||
|
||||
@ -1433,7 +1433,7 @@ int ssh_userauth_kbdint_getnprompts(SSH_SESSION *session) {
|
||||
*
|
||||
* @returns The name of the message block. Do not free it.
|
||||
*/
|
||||
const char *ssh_userauth_kbdint_getname(SSH_SESSION *session) {
|
||||
const char *ssh_userauth_kbdint_getname(ssh_session session) {
|
||||
return session->kbdint->name;
|
||||
}
|
||||
|
||||
@ -1448,7 +1448,7 @@ const char *ssh_userauth_kbdint_getname(SSH_SESSION *session) {
|
||||
* @returns The instruction of the message block.
|
||||
*/
|
||||
|
||||
const char *ssh_userauth_kbdint_getinstruction(SSH_SESSION *session) {
|
||||
const char *ssh_userauth_kbdint_getinstruction(ssh_session session) {
|
||||
return session->kbdint->instruction;
|
||||
}
|
||||
|
||||
@ -1468,7 +1468,7 @@ const char *ssh_userauth_kbdint_getinstruction(SSH_SESSION *session) {
|
||||
*
|
||||
* @returns A pointer to the prompt. Do not free it.
|
||||
*/
|
||||
const char *ssh_userauth_kbdint_getprompt(SSH_SESSION *session, unsigned int i,
|
||||
const char *ssh_userauth_kbdint_getprompt(ssh_session session, unsigned int i,
|
||||
char *echo) {
|
||||
if (i > session->kbdint->nprompts) {
|
||||
return NULL;
|
||||
@ -1489,7 +1489,7 @@ const char *ssh_userauth_kbdint_getprompt(SSH_SESSION *session, unsigned int i,
|
||||
* \param answer answer to give to server
|
||||
* \return 0 on success, < 0 on error.
|
||||
*/
|
||||
int ssh_userauth_kbdint_setanswer(SSH_SESSION *session, unsigned int i,
|
||||
int ssh_userauth_kbdint_setanswer(ssh_session session, unsigned int i,
|
||||
const char *answer) {
|
||||
if (session == NULL || answer == NULL || i > session->kbdint->nprompts) {
|
||||
return -1;
|
||||
|
@ -28,7 +28,7 @@
|
||||
#include "libssh/ssh1.h"
|
||||
|
||||
#ifdef WITH_SSH1
|
||||
static int wait_auth1_status(SSH_SESSION *session) {
|
||||
static int wait_auth1_status(ssh_session session) {
|
||||
/* wait for a packet */
|
||||
if (packet_read(session) != SSH_OK) {
|
||||
return SSH_AUTH_ERROR;
|
||||
@ -51,7 +51,7 @@ static int wait_auth1_status(SSH_SESSION *session) {
|
||||
return SSH_AUTH_ERROR;
|
||||
}
|
||||
|
||||
static int send_username(SSH_SESSION *session, const char *username) {
|
||||
static int send_username(ssh_session session, const char *username) {
|
||||
ssh_string user = NULL;
|
||||
/* returns SSH_AUTH_SUCCESS or SSH_AUTH_DENIED */
|
||||
if(session->auth_service_asked) {
|
||||
@ -91,12 +91,12 @@ static int send_username(SSH_SESSION *session, const char *username) {
|
||||
}
|
||||
|
||||
/* use the "none" authentication question */
|
||||
int ssh_userauth1_none(SSH_SESSION *session, const char *username){
|
||||
int ssh_userauth1_none(ssh_session session, const char *username){
|
||||
return send_username(session, username);
|
||||
}
|
||||
|
||||
/*
|
||||
int ssh_userauth_offer_pubkey(SSH_SESSION *session, char *username,int type, ssh_string publickey){
|
||||
int ssh_userauth_offer_pubkey(ssh_session session, char *username,int type, ssh_string publickey){
|
||||
ssh_string user;
|
||||
ssh_string service;
|
||||
ssh_string method;
|
||||
@ -136,7 +136,7 @@ int ssh_userauth_offer_pubkey(SSH_SESSION *session, char *username,int type, ssh
|
||||
/** \internal
|
||||
* \todo implement ssh1 public key
|
||||
*/
|
||||
int ssh_userauth1_offer_pubkey(SSH_SESSION *session, const char *username,
|
||||
int ssh_userauth1_offer_pubkey(ssh_session session, const char *username,
|
||||
int type, ssh_string pubkey) {
|
||||
(void) session;
|
||||
(void) username;
|
||||
@ -146,7 +146,7 @@ int ssh_userauth1_offer_pubkey(SSH_SESSION *session, const char *username,
|
||||
}
|
||||
|
||||
/*
|
||||
int ssh_userauth_pubkey(SSH_SESSION *session, char *username, ssh_string publickey, ssh_private_key privatekey){
|
||||
int ssh_userauth_pubkey(ssh_session session, char *username, ssh_string publickey, ssh_private_key privatekey){
|
||||
ssh_string user;
|
||||
ssh_string service;
|
||||
ssh_string method;
|
||||
@ -192,7 +192,7 @@ int ssh_userauth_pubkey(SSH_SESSION *session, char *username, ssh_string publick
|
||||
}
|
||||
*/
|
||||
|
||||
int ssh_userauth1_password(SSH_SESSION *session, const char *username,
|
||||
int ssh_userauth1_password(ssh_session session, const char *username,
|
||||
const char *password) {
|
||||
ssh_string pwd = NULL;
|
||||
int rc;
|
||||
|
@ -55,7 +55,7 @@
|
||||
*
|
||||
* @return A pointer to a newly allocated channel, NULL on error.
|
||||
*/
|
||||
ssh_channel channel_new(SSH_SESSION *session) {
|
||||
ssh_channel channel_new(ssh_session session) {
|
||||
ssh_channel channel = NULL;
|
||||
|
||||
channel = malloc(sizeof(struct ssh_channel_struct));
|
||||
@ -102,13 +102,13 @@ ssh_channel channel_new(SSH_SESSION *session) {
|
||||
*
|
||||
* @return The new channel identifier.
|
||||
*/
|
||||
uint32_t ssh_channel_new_id(SSH_SESSION *session) {
|
||||
uint32_t ssh_channel_new_id(ssh_session session) {
|
||||
return ++(session->maxchannel);
|
||||
}
|
||||
|
||||
static int channel_open(ssh_channel channel, const char *type_c, int window,
|
||||
int maxpacket, ssh_buffer payload) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
ssh_string type = NULL;
|
||||
uint32_t tmp = 0;
|
||||
|
||||
@ -233,7 +233,7 @@ static int channel_open(ssh_channel channel, const char *type_c, int window,
|
||||
}
|
||||
|
||||
/* get ssh channel from local session? */
|
||||
ssh_channel ssh_channel_from_local(SSH_SESSION *session, uint32_t id) {
|
||||
ssh_channel ssh_channel_from_local(ssh_session session, uint32_t id) {
|
||||
ssh_channel initchan = session->channels;
|
||||
ssh_channel channel;
|
||||
|
||||
@ -252,7 +252,7 @@ ssh_channel ssh_channel_from_local(SSH_SESSION *session, uint32_t id) {
|
||||
return channel;
|
||||
}
|
||||
|
||||
static int grow_window(SSH_SESSION *session, ssh_channel channel, int minimumsize) {
|
||||
static int grow_window(ssh_session session, ssh_channel channel, int minimumsize) {
|
||||
uint32_t new_window = minimumsize > WINDOWBASE ? minimumsize : WINDOWBASE;
|
||||
|
||||
enter_function();
|
||||
@ -286,7 +286,7 @@ error:
|
||||
return -1;
|
||||
}
|
||||
|
||||
static ssh_channel channel_from_msg(SSH_SESSION *session) {
|
||||
static ssh_channel channel_from_msg(ssh_session session) {
|
||||
ssh_channel channel;
|
||||
uint32_t chan;
|
||||
|
||||
@ -306,7 +306,7 @@ static ssh_channel channel_from_msg(SSH_SESSION *session) {
|
||||
return channel;
|
||||
}
|
||||
|
||||
static void channel_rcv_change_window(SSH_SESSION *session) {
|
||||
static void channel_rcv_change_window(ssh_session session) {
|
||||
ssh_channel channel;
|
||||
uint32_t bytes;
|
||||
int rc;
|
||||
@ -340,7 +340,7 @@ static void channel_rcv_change_window(SSH_SESSION *session) {
|
||||
}
|
||||
|
||||
/* is_stderr is set to 1 if the data are extended, ie stderr */
|
||||
static void channel_rcv_data(SSH_SESSION *session,int is_stderr) {
|
||||
static void channel_rcv_data(ssh_session session,int is_stderr) {
|
||||
ssh_channel channel;
|
||||
ssh_string str;
|
||||
size_t len;
|
||||
@ -406,7 +406,7 @@ static void channel_rcv_data(SSH_SESSION *session,int is_stderr) {
|
||||
leave_function();
|
||||
}
|
||||
|
||||
static void channel_rcv_eof(SSH_SESSION *session) {
|
||||
static void channel_rcv_eof(ssh_session session) {
|
||||
ssh_channel channel;
|
||||
|
||||
enter_function();
|
||||
@ -428,7 +428,7 @@ static void channel_rcv_eof(SSH_SESSION *session) {
|
||||
leave_function();
|
||||
}
|
||||
|
||||
static void channel_rcv_close(SSH_SESSION *session) {
|
||||
static void channel_rcv_close(ssh_session session) {
|
||||
ssh_channel channel;
|
||||
|
||||
enter_function();
|
||||
@ -467,7 +467,7 @@ static void channel_rcv_close(SSH_SESSION *session) {
|
||||
leave_function();
|
||||
}
|
||||
|
||||
static void channel_rcv_request(SSH_SESSION *session) {
|
||||
static void channel_rcv_request(ssh_session session) {
|
||||
ssh_channel channel;
|
||||
ssh_string request_s;
|
||||
char *request;
|
||||
@ -560,7 +560,7 @@ static void channel_rcv_request(SSH_SESSION *session) {
|
||||
* channel_handle() is called by packet_wait(), for example when there is
|
||||
* channel informations to handle.
|
||||
*/
|
||||
void channel_handle(SSH_SESSION *session, int type){
|
||||
void channel_handle(ssh_session session, int type){
|
||||
enter_function();
|
||||
|
||||
ssh_log(session, SSH_LOG_PROTOCOL, "Channel_handle(%d)", type);
|
||||
@ -681,7 +681,7 @@ int channel_open_session(ssh_channel channel) {
|
||||
*/
|
||||
int channel_open_forward(ssh_channel channel, const char *remotehost,
|
||||
int remoteport, const char *sourcehost, int localport) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
ssh_buffer payload = NULL;
|
||||
ssh_string str = NULL;
|
||||
int rc = SSH_ERROR;
|
||||
@ -731,7 +731,7 @@ error:
|
||||
* @warning Any data unread on this channel will be lost.
|
||||
*/
|
||||
void channel_free(ssh_channel channel) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
enter_function();
|
||||
|
||||
if (channel == NULL) {
|
||||
@ -780,7 +780,7 @@ void channel_free(ssh_channel channel) {
|
||||
* @see channel_free()
|
||||
*/
|
||||
int channel_send_eof(ssh_channel channel){
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
enter_function();
|
||||
@ -823,7 +823,7 @@ error:
|
||||
* @see channel_eof()
|
||||
*/
|
||||
int channel_close(ssh_channel channel){
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
int rc = 0;
|
||||
|
||||
enter_function();
|
||||
@ -863,7 +863,7 @@ error:
|
||||
|
||||
int channel_write_common(ssh_channel channel, const void *data,
|
||||
uint32_t len, int is_stderr) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
int origlen = len;
|
||||
int effectivelen;
|
||||
|
||||
@ -1021,7 +1021,7 @@ void channel_set_blocking(ssh_channel channel, int blocking) {
|
||||
|
||||
static int channel_request(ssh_channel channel, const char *request,
|
||||
ssh_buffer buffer, int reply) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
ssh_string req = NULL;
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
@ -1099,7 +1099,7 @@ error:
|
||||
*/
|
||||
int channel_request_pty_size(ssh_channel channel, const char *terminal,
|
||||
int col, int row) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
ssh_string term = NULL;
|
||||
ssh_buffer buffer = NULL;
|
||||
int rc = SSH_ERROR;
|
||||
@ -1168,7 +1168,7 @@ int channel_request_pty(ssh_channel channel) {
|
||||
* is running at same time (not 100% threadsafe).
|
||||
*/
|
||||
int channel_change_pty_size(ssh_channel channel, int cols, int rows) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
ssh_buffer buffer = NULL;
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
@ -1728,7 +1728,7 @@ error:
|
||||
*/
|
||||
int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
|
||||
int is_stderr) {
|
||||
SSH_SESSION *session=channel->session;
|
||||
ssh_session session=channel->session;
|
||||
ssh_buffer stdbuf = channel->stdout_buffer;
|
||||
uint32_t maxread = count;
|
||||
uint32_t len;
|
||||
@ -1836,7 +1836,7 @@ int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
|
||||
* channel_read_buffer().
|
||||
*/
|
||||
int channel_read(ssh_channel channel, void *dest, uint32_t count, int is_stderr) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
ssh_buffer stdbuf = channel->stdout_buffer;
|
||||
uint32_t len;
|
||||
|
||||
@ -1935,7 +1935,7 @@ int channel_read(ssh_channel channel, void *dest, uint32_t count, int is_stderr)
|
||||
*/
|
||||
int channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
|
||||
int is_stderr) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
uint32_t to_read;
|
||||
int rc;
|
||||
|
||||
@ -1972,7 +1972,7 @@ int channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
|
||||
* @see channel_is_eof()
|
||||
*/
|
||||
int channel_poll(ssh_channel channel, int is_stderr){
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
ssh_buffer stdbuf = channel->stdout_buffer;
|
||||
|
||||
enter_function();
|
||||
@ -2006,7 +2006,7 @@ int channel_poll(ssh_channel channel, int is_stderr){
|
||||
*
|
||||
* @return The session pointer.
|
||||
*/
|
||||
SSH_SESSION *channel_get_session(ssh_channel channel) {
|
||||
ssh_session channel_get_session(ssh_channel channel) {
|
||||
return channel->session;
|
||||
}
|
||||
|
||||
|
@ -45,7 +45,7 @@ int channel_open_session1(ssh_channel chan) {
|
||||
* We guess we are requesting an *exec* channel. It can only have one exec
|
||||
* channel. So we abort with an error if we need more than one.
|
||||
*/
|
||||
SSH_SESSION *session = chan->session;
|
||||
ssh_session session = chan->session;
|
||||
if (session->exec_channel_opened) {
|
||||
ssh_set_error(session, SSH_REQUEST_DENIED,
|
||||
"SSH1 supports only one execution channel. "
|
||||
@ -75,7 +75,7 @@ int channel_open_session1(ssh_channel chan) {
|
||||
|
||||
int channel_request_pty_size1(ssh_channel channel, const char *terminal, int col,
|
||||
int row) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
ssh_string str = NULL;
|
||||
|
||||
str = string_from_char(terminal);
|
||||
@ -127,7 +127,7 @@ int channel_request_pty_size1(ssh_channel channel, const char *terminal, int col
|
||||
}
|
||||
|
||||
int channel_change_pty_size1(ssh_channel channel, int cols, int rows) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
|
||||
if (buffer_add_u8(session->out_buffer, SSH_CMSG_WINDOW_SIZE) < 0 ||
|
||||
buffer_add_u32(session->out_buffer, ntohl(rows)) < 0 ||
|
||||
@ -164,7 +164,7 @@ int channel_change_pty_size1(ssh_channel channel, int cols, int rows) {
|
||||
}
|
||||
|
||||
int channel_request_shell1(ssh_channel channel) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
|
||||
if (buffer_add_u8(session->out_buffer,SSH_CMSG_EXEC_SHELL) < 0) {
|
||||
return -1;
|
||||
@ -180,7 +180,7 @@ int channel_request_shell1(ssh_channel channel) {
|
||||
}
|
||||
|
||||
int channel_request_exec1(ssh_channel channel, const char *cmd) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
ssh_string command = NULL;
|
||||
|
||||
command = string_from_char(cmd);
|
||||
@ -204,7 +204,7 @@ int channel_request_exec1(ssh_channel channel, const char *cmd) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int channel_rcv_data1(SSH_SESSION *session, int is_stderr) {
|
||||
static int channel_rcv_data1(ssh_session session, int is_stderr) {
|
||||
ssh_channel channel = session->channels;
|
||||
ssh_string str = NULL;
|
||||
|
||||
@ -228,7 +228,7 @@ static int channel_rcv_data1(SSH_SESSION *session, int is_stderr) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int channel_rcv_close1(SSH_SESSION *session) {
|
||||
static int channel_rcv_close1(ssh_session session) {
|
||||
ssh_channel channel = session->channels;
|
||||
uint32_t status;
|
||||
|
||||
@ -253,7 +253,7 @@ static int channel_rcv_close1(SSH_SESSION *session) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int channel_handle1(SSH_SESSION *session, int type) {
|
||||
int channel_handle1(ssh_session session, int type) {
|
||||
ssh_log(session, SSH_LOG_RARE, "Channel_handle1(%d)", type);
|
||||
switch (type) {
|
||||
case SSH_SMSG_STDOUT_DATA:
|
||||
@ -279,7 +279,7 @@ int channel_handle1(SSH_SESSION *session, int type) {
|
||||
}
|
||||
|
||||
int channel_write1(ssh_channel channel, const void *data, int len) {
|
||||
SSH_SESSION *session = channel->session;
|
||||
ssh_session session = channel->session;
|
||||
int origlen = len;
|
||||
int effectivelen;
|
||||
const unsigned char *ptr=data;
|
||||
|
@ -48,7 +48,7 @@
|
||||
*
|
||||
* @return A newly allocated string with the banner or NULL on error.
|
||||
*/
|
||||
char *ssh_get_banner(SSH_SESSION *session) {
|
||||
char *ssh_get_banner(ssh_session session) {
|
||||
char buffer[128] = {0};
|
||||
char *str = NULL;
|
||||
int i;
|
||||
@ -97,7 +97,7 @@ char *ssh_get_banner(SSH_SESSION *session) {
|
||||
*
|
||||
* @see ssh_get_banner()
|
||||
*/
|
||||
static int ssh_analyze_banner(SSH_SESSION *session, int *ssh1, int *ssh2) {
|
||||
static int ssh_analyze_banner(ssh_session session, int *ssh1, int *ssh2) {
|
||||
const char *banner = session->serverbanner;
|
||||
const char *openssh;
|
||||
|
||||
@ -155,7 +155,7 @@ static int ssh_analyze_banner(SSH_SESSION *session, int *ssh1, int *ssh2) {
|
||||
*
|
||||
* @return 0 on success, < 0 on error.
|
||||
*/
|
||||
int ssh_send_banner(SSH_SESSION *session, int server) {
|
||||
int ssh_send_banner(ssh_session session, int server) {
|
||||
const char *banner = NULL;
|
||||
char buffer[128] = {0};
|
||||
|
||||
@ -203,7 +203,7 @@ int ssh_send_banner(SSH_SESSION *session, int server) {
|
||||
#define DH_STATE_NEWKEYS_TO_SEND 3
|
||||
#define DH_STATE_NEWKEYS_SENT 4
|
||||
#define DH_STATE_FINISHED 5
|
||||
static int dh_handshake(SSH_SESSION *session) {
|
||||
static int dh_handshake(ssh_session session) {
|
||||
ssh_string e = NULL;
|
||||
ssh_string f = NULL;
|
||||
ssh_string pubkey = NULL;
|
||||
@ -413,7 +413,7 @@ error:
|
||||
*
|
||||
* @return 0 on success, < 0 on error.
|
||||
*/
|
||||
int ssh_service_request(SSH_SESSION *session, const char *service) {
|
||||
int ssh_service_request(ssh_session session, const char *service) {
|
||||
ssh_string service_s = NULL;
|
||||
|
||||
enter_function();
|
||||
@ -469,7 +469,7 @@ int ssh_service_request(SSH_SESSION *session, const char *service) {
|
||||
* \see ssh_new()
|
||||
* \see ssh_disconnect()
|
||||
*/
|
||||
int ssh_connect(SSH_SESSION *session) {
|
||||
int ssh_connect(ssh_session session) {
|
||||
SSH_OPTIONS *options = session->options;
|
||||
int ssh1 = 0;
|
||||
int ssh2 = 0;
|
||||
@ -621,7 +621,7 @@ int ssh_connect(SSH_SESSION *session) {
|
||||
*
|
||||
* @return A newly allocated string with the banner, NULL on error.
|
||||
*/
|
||||
char *ssh_get_issue_banner(SSH_SESSION *session) {
|
||||
char *ssh_get_issue_banner(ssh_session session) {
|
||||
if (session == NULL || session->banner == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
@ -652,7 +652,7 @@ int ssh_get_openssh_version(ssh_session session) {
|
||||
*
|
||||
* @param session The SSH session to disconnect.
|
||||
*/
|
||||
void ssh_disconnect(SSH_SESSION *session) {
|
||||
void ssh_disconnect(ssh_session session) {
|
||||
ssh_string str = NULL;
|
||||
|
||||
if (session == NULL) {
|
||||
|
@ -167,7 +167,7 @@ static int ssh_connect_socket_close(socket_t s){
|
||||
}
|
||||
|
||||
|
||||
static int getai(SSH_SESSION *session, const char *host, int port, struct addrinfo **ai) {
|
||||
static int getai(ssh_session session, const char *host, int port, struct addrinfo **ai) {
|
||||
const char *service = NULL;
|
||||
struct addrinfo hints;
|
||||
char s_port[10];
|
||||
@ -197,7 +197,7 @@ static int getai(SSH_SESSION *session, const char *host, int port, struct addrin
|
||||
return getaddrinfo(host, service, &hints, ai);
|
||||
}
|
||||
|
||||
static int ssh_connect_ai_timeout(SSH_SESSION *session, const char *host,
|
||||
static int ssh_connect_ai_timeout(ssh_session session, const char *host,
|
||||
int port, struct addrinfo *ai, long timeout, long usec, socket_t s) {
|
||||
struct timeval to;
|
||||
fd_set set;
|
||||
@ -263,7 +263,7 @@ static int ssh_connect_ai_timeout(SSH_SESSION *session, const char *host,
|
||||
*
|
||||
* @returns A file descriptor, < 0 on error.
|
||||
*/
|
||||
socket_t ssh_connect_host(SSH_SESSION *session, const char *host,
|
||||
socket_t ssh_connect_host(ssh_session session, const char *host,
|
||||
const char *bind_addr, int port, long timeout, long usec) {
|
||||
socket_t s = -1;
|
||||
int rc;
|
||||
|
@ -38,7 +38,7 @@
|
||||
#include "libssh/priv.h"
|
||||
#include "libssh/crypto.h"
|
||||
|
||||
uint32_t packet_decrypt_len(SSH_SESSION *session, char *crypted){
|
||||
uint32_t packet_decrypt_len(ssh_session session, char *crypted){
|
||||
uint32_t decrypted;
|
||||
|
||||
if (session->current_crypto) {
|
||||
@ -56,7 +56,7 @@ uint32_t packet_decrypt_len(SSH_SESSION *session, char *crypted){
|
||||
return ntohl(decrypted);
|
||||
}
|
||||
|
||||
int packet_decrypt(SSH_SESSION *session, void *data,uint32_t len) {
|
||||
int packet_decrypt(ssh_session session, void *data,uint32_t len) {
|
||||
struct crypto_struct *crypto = session->current_crypto->in_cipher;
|
||||
char *out = NULL;
|
||||
if(len % session->current_crypto->in_cipher->blocksize != 0){
|
||||
@ -92,7 +92,7 @@ int packet_decrypt(SSH_SESSION *session, void *data,uint32_t len) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
unsigned char *packet_encrypt(SSH_SESSION *session, void *data, uint32_t len) {
|
||||
unsigned char *packet_encrypt(ssh_session session, void *data, uint32_t len) {
|
||||
struct crypto_struct *crypto = NULL;
|
||||
HMACCTX ctx = NULL;
|
||||
char *out = NULL;
|
||||
@ -179,7 +179,7 @@ unsigned char *packet_encrypt(SSH_SESSION *session, void *data, uint32_t len) {
|
||||
* @return 0 if hmac and mac are equal, < 0 if not or an error
|
||||
* occured.
|
||||
*/
|
||||
int packet_hmac_verify(SSH_SESSION *session, ssh_buffer buffer,
|
||||
int packet_hmac_verify(ssh_session session, ssh_buffer buffer,
|
||||
unsigned char *mac) {
|
||||
unsigned char hmacbuf[EVP_MAX_MD_SIZE] = {0};
|
||||
HMACCTX ctx;
|
||||
|
36
libssh/dh.c
36
libssh/dh.c
@ -217,7 +217,7 @@ void ssh_print_hexa(const char *descr, const unsigned char *what, size_t len) {
|
||||
printf("%s: %s\n", descr, hexa);
|
||||
}
|
||||
|
||||
int dh_generate_x(SSH_SESSION *session) {
|
||||
int dh_generate_x(ssh_session session) {
|
||||
session->next_crypto->x = bignum_new();
|
||||
if (session->next_crypto->x == NULL) {
|
||||
return -1;
|
||||
@ -238,7 +238,7 @@ int dh_generate_x(SSH_SESSION *session) {
|
||||
}
|
||||
|
||||
/* used by server */
|
||||
int dh_generate_y(SSH_SESSION *session) {
|
||||
int dh_generate_y(ssh_session session) {
|
||||
session->next_crypto->y = bignum_new();
|
||||
if (session->next_crypto->y == NULL) {
|
||||
return -1;
|
||||
@ -259,7 +259,7 @@ int dh_generate_y(SSH_SESSION *session) {
|
||||
}
|
||||
|
||||
/* used by server */
|
||||
int dh_generate_e(SSH_SESSION *session) {
|
||||
int dh_generate_e(ssh_session session) {
|
||||
#ifdef HAVE_LIBCRYPTO
|
||||
bignum_CTX ctx = bignum_ctx_new();
|
||||
if (ctx == NULL) {
|
||||
@ -292,7 +292,7 @@ int dh_generate_e(SSH_SESSION *session) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int dh_generate_f(SSH_SESSION *session) {
|
||||
int dh_generate_f(ssh_session session) {
|
||||
#ifdef HAVE_LIBCRYPTO
|
||||
bignum_CTX ctx = bignum_ctx_new();
|
||||
if (ctx == NULL) {
|
||||
@ -377,20 +377,20 @@ bignum make_string_bn(ssh_string string){
|
||||
return bn;
|
||||
}
|
||||
|
||||
ssh_string dh_get_e(SSH_SESSION *session) {
|
||||
ssh_string dh_get_e(ssh_session session) {
|
||||
return make_bignum_string(session->next_crypto->e);
|
||||
}
|
||||
|
||||
/* used by server */
|
||||
ssh_string dh_get_f(SSH_SESSION *session) {
|
||||
ssh_string dh_get_f(ssh_session session) {
|
||||
return make_bignum_string(session->next_crypto->f);
|
||||
}
|
||||
|
||||
void dh_import_pubkey(SSH_SESSION *session, ssh_string pubkey_string) {
|
||||
void dh_import_pubkey(ssh_session session, ssh_string pubkey_string) {
|
||||
session->next_crypto->server_pubkey = pubkey_string;
|
||||
}
|
||||
|
||||
int dh_import_f(SSH_SESSION *session, ssh_string f_string) {
|
||||
int dh_import_f(ssh_session session, ssh_string f_string) {
|
||||
session->next_crypto->f = make_string_bn(f_string);
|
||||
if (session->next_crypto->f == NULL) {
|
||||
return -1;
|
||||
@ -404,7 +404,7 @@ int dh_import_f(SSH_SESSION *session, ssh_string f_string) {
|
||||
}
|
||||
|
||||
/* used by the server implementation */
|
||||
int dh_import_e(SSH_SESSION *session, ssh_string e_string) {
|
||||
int dh_import_e(ssh_session session, ssh_string e_string) {
|
||||
session->next_crypto->e = make_string_bn(e_string);
|
||||
if (session->next_crypto->e == NULL) {
|
||||
return -1;
|
||||
@ -417,7 +417,7 @@ int dh_import_e(SSH_SESSION *session, ssh_string e_string) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int dh_build_k(SSH_SESSION *session) {
|
||||
int dh_build_k(ssh_session session) {
|
||||
#ifdef HAVE_LIBCRYPTO
|
||||
bignum_CTX ctx = bignum_ctx_new();
|
||||
if (ctx == NULL) {
|
||||
@ -474,7 +474,7 @@ static void sha_add(ssh_string str,SHACTX ctx){
|
||||
}
|
||||
*/
|
||||
|
||||
int make_sessionid(SSH_SESSION *session) {
|
||||
int make_sessionid(ssh_session session) {
|
||||
SHACTX ctx;
|
||||
ssh_string num = NULL;
|
||||
ssh_string str = NULL;
|
||||
@ -620,7 +620,7 @@ error:
|
||||
return rc;
|
||||
}
|
||||
|
||||
int hashbufout_add_cookie(SSH_SESSION *session) {
|
||||
int hashbufout_add_cookie(ssh_session session) {
|
||||
session->out_hashbuf = buffer_new();
|
||||
if (session->out_hashbuf == NULL) {
|
||||
return -1;
|
||||
@ -648,7 +648,7 @@ int hashbufout_add_cookie(SSH_SESSION *session) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int hashbufin_add_cookie(SSH_SESSION *session, unsigned char *cookie) {
|
||||
int hashbufin_add_cookie(ssh_session session, unsigned char *cookie) {
|
||||
session->in_hashbuf = buffer_new();
|
||||
if (session->in_hashbuf == NULL) {
|
||||
return -1;
|
||||
@ -686,7 +686,7 @@ static int generate_one_key(ssh_string k,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int generate_session_keys(SSH_SESSION *session) {
|
||||
int generate_session_keys(ssh_session session) {
|
||||
ssh_string k_string = NULL;
|
||||
SHACTX ctx = NULL;
|
||||
int rc = -1;
|
||||
@ -816,7 +816,7 @@ error:
|
||||
* @see ssh_get_hexa()
|
||||
* @see ssh_print_hexa()
|
||||
*/
|
||||
int ssh_get_pubkey_hash(SSH_SESSION *session, unsigned char **hash) {
|
||||
int ssh_get_pubkey_hash(ssh_session session, unsigned char **hash) {
|
||||
ssh_string pubkey;
|
||||
MD5CTX ctx;
|
||||
unsigned char *h;
|
||||
@ -864,7 +864,7 @@ void ssh_clean_pubkey_hash(unsigned char **hash) {
|
||||
*hash = NULL;
|
||||
}
|
||||
|
||||
ssh_string ssh_get_pubkey(SSH_SESSION *session){
|
||||
ssh_string ssh_get_pubkey(ssh_session session){
|
||||
return string_copy(session->current_crypto->server_pubkey);
|
||||
}
|
||||
|
||||
@ -892,7 +892,7 @@ static int match(const char *group, const char *object){
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sig_verify(SSH_SESSION *session, ssh_public_key pubkey,
|
||||
int sig_verify(ssh_session session, ssh_public_key pubkey,
|
||||
SIGNATURE *signature, unsigned char *digest, int size) {
|
||||
#ifdef HAVE_LIBGCRYPT
|
||||
gcry_error_t valid = 0;
|
||||
@ -987,7 +987,7 @@ int sig_verify(SSH_SESSION *session, ssh_public_key pubkey,
|
||||
return -1;
|
||||
}
|
||||
|
||||
int signature_verify(SSH_SESSION *session, ssh_string signature) {
|
||||
int signature_verify(ssh_session session, ssh_string signature) {
|
||||
ssh_public_key pubkey = NULL;
|
||||
SIGNATURE *sign = NULL;
|
||||
int err;
|
||||
|
@ -33,7 +33,7 @@
|
||||
|
||||
#define BLOCKSIZE 4092
|
||||
|
||||
static z_stream *initcompress(SSH_SESSION *session, int level) {
|
||||
static z_stream *initcompress(ssh_session session, int level) {
|
||||
z_stream *stream = NULL;
|
||||
int status;
|
||||
|
||||
@ -54,7 +54,7 @@ static z_stream *initcompress(SSH_SESSION *session, int level) {
|
||||
return stream;
|
||||
}
|
||||
|
||||
static ssh_buffer gzip_compress(SSH_SESSION *session,ssh_buffer source,int level){
|
||||
static ssh_buffer gzip_compress(ssh_session session,ssh_buffer source,int level){
|
||||
z_stream *zout = session->current_crypto->compress_out_ctx;
|
||||
void *in_ptr = buffer_get(source);
|
||||
unsigned long in_size = buffer_get_len(source);
|
||||
@ -98,7 +98,7 @@ static ssh_buffer gzip_compress(SSH_SESSION *session,ssh_buffer source,int level
|
||||
return dest;
|
||||
}
|
||||
|
||||
int compress_buffer(SSH_SESSION *session, ssh_buffer buf) {
|
||||
int compress_buffer(ssh_session session, ssh_buffer buf) {
|
||||
ssh_buffer dest = NULL;
|
||||
|
||||
dest = gzip_compress(session, buf, 9);
|
||||
@ -122,7 +122,7 @@ int compress_buffer(SSH_SESSION *session, ssh_buffer buf) {
|
||||
|
||||
/* decompression */
|
||||
|
||||
static z_stream *initdecompress(SSH_SESSION *session) {
|
||||
static z_stream *initdecompress(ssh_session session) {
|
||||
z_stream *stream = NULL;
|
||||
int status;
|
||||
|
||||
@ -143,7 +143,7 @@ static z_stream *initdecompress(SSH_SESSION *session) {
|
||||
return stream;
|
||||
}
|
||||
|
||||
static ssh_buffer gzip_decompress(SSH_SESSION *session, ssh_buffer source, size_t maxlen) {
|
||||
static ssh_buffer gzip_decompress(ssh_session session, ssh_buffer source, size_t maxlen) {
|
||||
z_stream *zin = session->current_crypto->compress_in_ctx;
|
||||
void *in_ptr = buffer_get_rest(source);
|
||||
unsigned long in_size = buffer_get_rest_len(source);
|
||||
@ -194,7 +194,7 @@ static ssh_buffer gzip_decompress(SSH_SESSION *session, ssh_buffer source, size_
|
||||
return dest;
|
||||
}
|
||||
|
||||
int decompress_buffer(SSH_SESSION *session,ssh_buffer buf, size_t maxlen){
|
||||
int decompress_buffer(ssh_session session,ssh_buffer buf, size_t maxlen){
|
||||
ssh_buffer dest = NULL;
|
||||
|
||||
dest = gzip_decompress(session,buf, maxlen);
|
||||
|
12
libssh/kex.c
12
libssh/kex.c
@ -232,7 +232,7 @@ char *ssh_find_matching(const char *in_d, const char *what_d){
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int ssh_get_kex(SSH_SESSION *session, int server_kex) {
|
||||
int ssh_get_kex(ssh_session session, int server_kex) {
|
||||
ssh_string str = NULL;
|
||||
char *strings[10];
|
||||
int i;
|
||||
@ -328,7 +328,7 @@ void ssh_list_kex(ssh_session session, KEX *kex) {
|
||||
/* it must be aware of the server kex message */
|
||||
/* it can fail if option is null, not any user specified kex method matches the server one, if not any default kex matches */
|
||||
|
||||
int set_kex(SSH_SESSION *session){
|
||||
int set_kex(ssh_session session){
|
||||
KEX *server = &session->server_kex;
|
||||
KEX *client=&session->client_kex;
|
||||
SSH_OPTIONS *options=session->options;
|
||||
@ -371,7 +371,7 @@ int set_kex(SSH_SESSION *session){
|
||||
}
|
||||
|
||||
/* this function only sends the predefined set of kex methods */
|
||||
int ssh_send_kex(SSH_SESSION *session, int server_kex) {
|
||||
int ssh_send_kex(ssh_session session, int server_kex) {
|
||||
KEX *kex = (server_kex ? &session->server_kex : &session->client_kex);
|
||||
ssh_string str = NULL;
|
||||
int i;
|
||||
@ -475,7 +475,7 @@ error:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int build_session_id1(SSH_SESSION *session, ssh_string servern,
|
||||
static int build_session_id1(ssh_session session, ssh_string servern,
|
||||
ssh_string hostn) {
|
||||
MD5CTX md5 = NULL;
|
||||
|
||||
@ -529,7 +529,7 @@ static int modulus_smaller(ssh_public_key k1, ssh_public_key k2){
|
||||
}
|
||||
|
||||
#define ABS(A) ( (A)<0 ? -(A):(A) )
|
||||
static ssh_string encrypt_session_key(SSH_SESSION *session, ssh_public_key srvkey,
|
||||
static ssh_string encrypt_session_key(ssh_session session, ssh_public_key srvkey,
|
||||
ssh_public_key hostkey, int slen, int hlen) {
|
||||
unsigned char buffer[32] = {0};
|
||||
int i;
|
||||
@ -606,7 +606,7 @@ static ssh_string encrypt_session_key(SSH_SESSION *session, ssh_public_key srvke
|
||||
* 32-bit int supported_authentications_mask
|
||||
*/
|
||||
|
||||
int ssh_get_kex1(SSH_SESSION *session) {
|
||||
int ssh_get_kex1(ssh_session session) {
|
||||
ssh_string server_exp = NULL;
|
||||
ssh_string server_mod = NULL;
|
||||
ssh_string host_exp = NULL;
|
||||
|
@ -577,7 +577,7 @@ error:
|
||||
|
||||
#ifdef HAVE_LIBCRYPTO
|
||||
static int pem_get_password(char *buf, int size, int rwflag, void *userdata) {
|
||||
SSH_SESSION *session = userdata;
|
||||
ssh_session session = userdata;
|
||||
|
||||
/* unused flag */
|
||||
(void) rwflag;
|
||||
@ -612,7 +612,7 @@ static int pem_get_password(char *buf, int size, int rwflag, void *userdata) {
|
||||
* \see privatekey_free()
|
||||
* \see publickey_from_privatekey()
|
||||
*/
|
||||
ssh_private_key privatekey_from_file(SSH_SESSION *session, const char *filename,
|
||||
ssh_private_key privatekey_from_file(ssh_session session, const char *filename,
|
||||
int type, const char *passphrase) {
|
||||
ssh_auth_callback auth_cb = NULL;
|
||||
ssh_private_key privkey = NULL;
|
||||
@ -857,7 +857,7 @@ void privatekey_free(ssh_private_key prv) {
|
||||
* \see string_free()
|
||||
* \see publickey_from_privatekey()
|
||||
*/
|
||||
ssh_string publickey_from_file(SSH_SESSION *session, const char *filename,
|
||||
ssh_string publickey_from_file(ssh_session session, const char *filename,
|
||||
int *type) {
|
||||
ssh_buffer buffer = NULL;
|
||||
char buf[4096] = {0};
|
||||
@ -926,7 +926,7 @@ ssh_string publickey_from_file(SSH_SESSION *session, const char *filename,
|
||||
return str;
|
||||
}
|
||||
|
||||
ssh_string try_publickey_from_file(SSH_SESSION *session, struct ssh_keys_struct keytab,
|
||||
ssh_string try_publickey_from_file(ssh_session session, struct ssh_keys_struct keytab,
|
||||
char **privkeyfile, int *type) {
|
||||
static char *home = NULL;
|
||||
|
||||
@ -1063,7 +1063,7 @@ static void tokens_free(char **tokens) {
|
||||
* \returns NULL if no match was found or the file was not found
|
||||
* \returns found_type type of key (ie "dsa","ssh-rsa1"). Don't free that value.
|
||||
*/
|
||||
static char **ssh_get_knownhost_line(SSH_SESSION *session, FILE **file,
|
||||
static char **ssh_get_knownhost_line(ssh_session session, FILE **file,
|
||||
const char *filename, const char **found_type) {
|
||||
char buffer[4096] = {0};
|
||||
char *ptr;
|
||||
@ -1145,7 +1145,7 @@ static char **ssh_get_knownhost_line(SSH_SESSION *session, FILE **file,
|
||||
* \return 0 if the key doesn't match
|
||||
* \return -1 on error
|
||||
*/
|
||||
static int check_public_key(SSH_SESSION *session, char **tokens) {
|
||||
static int check_public_key(ssh_session session, char **tokens) {
|
||||
ssh_string pubkey = session->current_crypto->server_pubkey;
|
||||
ssh_buffer pubkey_buffer;
|
||||
char *pubkey_64;
|
||||
@ -1244,7 +1244,7 @@ static int check_public_key(SSH_SESSION *session, char **tokens) {
|
||||
* \returns 1 if it matches
|
||||
* \returns 0 otherwise
|
||||
*/
|
||||
static int match_hashed_host(SSH_SESSION *session, const char *host,
|
||||
static int match_hashed_host(ssh_session session, const char *host,
|
||||
const char *sourcehash) {
|
||||
/* Openssh hash structure :
|
||||
* |1|base64 encoded salt|base64 encoded hash
|
||||
@ -1362,7 +1362,7 @@ static int match_hashed_host(SSH_SESSION *session, const char *host,
|
||||
* \bug There is no current way to remove or modify an entry into the known
|
||||
* host table.
|
||||
*/
|
||||
int ssh_is_server_known(SSH_SESSION *session) {
|
||||
int ssh_is_server_known(ssh_session session) {
|
||||
FILE *file = NULL;
|
||||
char **tokens;
|
||||
char *host;
|
||||
@ -1450,7 +1450,7 @@ int ssh_is_server_known(SSH_SESSION *session) {
|
||||
* \param session ssh session
|
||||
* \return 0 on success, -1 on error
|
||||
*/
|
||||
int ssh_write_knownhost(SSH_SESSION *session) {
|
||||
int ssh_write_knownhost(ssh_session session) {
|
||||
ssh_string pubkey = session->current_crypto->server_pubkey;
|
||||
unsigned char *pubkey_64;
|
||||
char buffer[4096] = {0};
|
||||
|
@ -67,7 +67,7 @@ int ssh_type_from_name(const char *name) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
ssh_public_key publickey_make_dss(SSH_SESSION *session, ssh_buffer buffer) {
|
||||
ssh_public_key publickey_make_dss(ssh_session session, ssh_buffer buffer) {
|
||||
ssh_string p = NULL;
|
||||
ssh_string q = NULL;
|
||||
ssh_string g = NULL;
|
||||
@ -153,7 +153,7 @@ error:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ssh_public_key publickey_make_rsa(SSH_SESSION *session, ssh_buffer buffer,
|
||||
ssh_public_key publickey_make_rsa(ssh_session session, ssh_buffer buffer,
|
||||
int type) {
|
||||
ssh_string e = NULL;
|
||||
ssh_string n = NULL;
|
||||
@ -247,7 +247,7 @@ void publickey_free(ssh_public_key key) {
|
||||
SAFE_FREE(key);
|
||||
}
|
||||
|
||||
ssh_public_key publickey_from_string(SSH_SESSION *session, ssh_string pubkey_s) {
|
||||
ssh_public_key publickey_from_string(ssh_session session, ssh_string pubkey_s) {
|
||||
ssh_buffer tmpbuf = NULL;
|
||||
ssh_string type_s = NULL;
|
||||
char *type_c = NULL;
|
||||
@ -847,7 +847,7 @@ static ssh_string signature_to_string(SIGNATURE *sign) {
|
||||
}
|
||||
|
||||
/* TODO : split this function in two so it becomes smaller */
|
||||
SIGNATURE *signature_from_string(SSH_SESSION *session, ssh_string signature,
|
||||
SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,
|
||||
ssh_public_key pubkey, int needed_type) {
|
||||
SIGNATURE *sign = NULL;
|
||||
ssh_buffer tmpbuf = NULL;
|
||||
@ -1151,7 +1151,7 @@ ssh_string ssh_do_sign_with_agent(ssh_session session,
|
||||
/*
|
||||
* This function concats in a buffer the values needed to do a signature
|
||||
* verification. */
|
||||
ssh_buffer ssh_userauth_build_digest(SSH_SESSION *session, ssh_message msg, char *service) {
|
||||
ssh_buffer ssh_userauth_build_digest(ssh_session session, ssh_message msg, char *service) {
|
||||
/*
|
||||
The value of 'signature' is a signature by the corresponding private
|
||||
key over the following data, in the following order:
|
||||
@ -1215,7 +1215,7 @@ error:
|
||||
/*
|
||||
* This function signs the session id (known as H) as a string then
|
||||
* the content of sigbuf */
|
||||
ssh_string ssh_do_sign(SSH_SESSION *session, ssh_buffer sigbuf,
|
||||
ssh_string ssh_do_sign(ssh_session session, ssh_buffer sigbuf,
|
||||
ssh_private_key privatekey) {
|
||||
CRYPTO *crypto = session->current_crypto ? session->current_crypto :
|
||||
session->next_crypto;
|
||||
@ -1314,7 +1314,7 @@ ssh_string ssh_do_sign(SSH_SESSION *session, ssh_buffer sigbuf,
|
||||
return signature;
|
||||
}
|
||||
|
||||
ssh_string ssh_encrypt_rsa1(SSH_SESSION *session, ssh_string data, ssh_public_key key) {
|
||||
ssh_string ssh_encrypt_rsa1(ssh_session session, ssh_string data, ssh_public_key key) {
|
||||
ssh_string str = NULL;
|
||||
size_t len = string_len(data);
|
||||
size_t size = 0;
|
||||
@ -1380,7 +1380,7 @@ ssh_string ssh_encrypt_rsa1(SSH_SESSION *session, ssh_string data, ssh_public_ke
|
||||
|
||||
|
||||
/* this function signs the session id */
|
||||
ssh_string ssh_sign_session_id(SSH_SESSION *session, ssh_private_key privatekey) {
|
||||
ssh_string ssh_sign_session_id(ssh_session session, ssh_private_key privatekey) {
|
||||
CRYPTO *crypto=session->current_crypto ? session->current_crypto :
|
||||
session->next_crypto;
|
||||
unsigned char hash[SHA_DIGEST_LEN + 1] = {0};
|
||||
|
@ -44,7 +44,7 @@
|
||||
*
|
||||
* @param format The format string of the log entry.
|
||||
*/
|
||||
void ssh_log(SSH_SESSION *session, int verbosity, const char *format, ...) {
|
||||
void ssh_log(ssh_session session, int verbosity, const char *format, ...) {
|
||||
char buffer[1024];
|
||||
char indent[256];
|
||||
int min;
|
||||
|
@ -44,7 +44,7 @@
|
||||
#include "libssh/ssh2.h"
|
||||
|
||||
|
||||
static SSH_MESSAGE *message_new(SSH_SESSION *session){
|
||||
static SSH_MESSAGE *message_new(ssh_session session){
|
||||
SSH_MESSAGE *msg = malloc(sizeof(SSH_MESSAGE));
|
||||
if (msg == NULL) {
|
||||
return NULL;
|
||||
@ -55,7 +55,7 @@ static SSH_MESSAGE *message_new(SSH_SESSION *session){
|
||||
return msg;
|
||||
}
|
||||
|
||||
static SSH_MESSAGE *handle_service_request(SSH_SESSION *session) {
|
||||
static SSH_MESSAGE *handle_service_request(ssh_session session) {
|
||||
ssh_string service = NULL;
|
||||
char *service_c = NULL;
|
||||
SSH_MESSAGE *msg=NULL;
|
||||
@ -86,7 +86,7 @@ static SSH_MESSAGE *handle_service_request(SSH_SESSION *session) {
|
||||
return msg;
|
||||
}
|
||||
|
||||
static int handle_unimplemented(SSH_SESSION *session) {
|
||||
static int handle_unimplemented(ssh_session session) {
|
||||
if (buffer_add_u32(session->out_buffer, htonl(session->recv_seq - 1)) < 0) {
|
||||
return -1;
|
||||
}
|
||||
@ -98,7 +98,7 @@ static int handle_unimplemented(SSH_SESSION *session) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static SSH_MESSAGE *handle_userauth_request(SSH_SESSION *session){
|
||||
static SSH_MESSAGE *handle_userauth_request(ssh_session session){
|
||||
ssh_string user = NULL;
|
||||
ssh_string service = NULL;
|
||||
ssh_string method = NULL;
|
||||
@ -264,7 +264,7 @@ error:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static SSH_MESSAGE *handle_channel_request_open(SSH_SESSION *session) {
|
||||
static SSH_MESSAGE *handle_channel_request_open(ssh_session session) {
|
||||
SSH_MESSAGE *msg = NULL;
|
||||
ssh_string type = NULL, originator = NULL, destination = NULL;
|
||||
char *type_c = NULL;
|
||||
@ -414,7 +414,7 @@ error:
|
||||
}
|
||||
|
||||
ssh_channel ssh_message_channel_request_open_reply_accept(SSH_MESSAGE *msg) {
|
||||
SSH_SESSION *session = msg->session;
|
||||
ssh_session session = msg->session;
|
||||
ssh_channel chan = NULL;
|
||||
|
||||
enter_function();
|
||||
@ -470,7 +470,7 @@ error:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static SSH_MESSAGE *handle_channel_request(SSH_SESSION *session) {
|
||||
static SSH_MESSAGE *handle_channel_request(ssh_session session) {
|
||||
SSH_MESSAGE *msg = NULL;
|
||||
ssh_string type = NULL;
|
||||
char *type_c = NULL;
|
||||
@ -693,7 +693,7 @@ int ssh_message_channel_request_reply_success(SSH_MESSAGE *msg) {
|
||||
return SSH_OK;
|
||||
}
|
||||
|
||||
SSH_MESSAGE *ssh_message_retrieve(SSH_SESSION *session, uint32_t packettype){
|
||||
SSH_MESSAGE *ssh_message_retrieve(ssh_session session, uint32_t packettype){
|
||||
SSH_MESSAGE *msg=NULL;
|
||||
enter_function();
|
||||
switch(packettype) {
|
||||
@ -722,7 +722,7 @@ SSH_MESSAGE *ssh_message_retrieve(SSH_SESSION *session, uint32_t packettype){
|
||||
/* \brief blocking message retrieval
|
||||
* \bug does anything that is not a message, like a channel read/write
|
||||
*/
|
||||
SSH_MESSAGE *ssh_message_get(SSH_SESSION *session) {
|
||||
SSH_MESSAGE *ssh_message_get(ssh_session session) {
|
||||
SSH_MESSAGE *msg = NULL;
|
||||
enter_function();
|
||||
do {
|
||||
@ -799,7 +799,7 @@ void ssh_message_free(SSH_MESSAGE *msg){
|
||||
* \param type packet type
|
||||
* \returns nothing
|
||||
*/
|
||||
void message_handle(SSH_SESSION *session, uint32_t type){
|
||||
void message_handle(ssh_session session, uint32_t type){
|
||||
SSH_MESSAGE *msg=ssh_message_retrieve(session,type);
|
||||
if(msg){
|
||||
if(!session->ssh_message_list){
|
||||
|
@ -47,7 +47,7 @@ static int macsize=SHA_DIGEST_LEN;
|
||||
#define PACKET_STATE_INIT 0
|
||||
#define PACKET_STATE_SIZEREAD 1
|
||||
|
||||
static int packet_read2(SSH_SESSION *session) {
|
||||
static int packet_read2(ssh_session session) {
|
||||
unsigned int blocksize = (session->current_crypto ?
|
||||
session->current_crypto->in_cipher->blocksize : 8);
|
||||
int current_macsize = session->current_crypto ? macsize : 0;
|
||||
@ -215,7 +215,7 @@ error:
|
||||
|
||||
#ifdef WITH_SSH1
|
||||
/* a slighty modified packet_read2() for SSH-1 protocol */
|
||||
static int packet_read1(SSH_SESSION *session) {
|
||||
static int packet_read1(ssh_session session) {
|
||||
void *packet = NULL;
|
||||
int rc = SSH_ERROR;
|
||||
int to_be_read;
|
||||
@ -365,7 +365,7 @@ error:
|
||||
#endif /* WITH_SSH1 */
|
||||
|
||||
/* that's where i'd like C to be object ... */
|
||||
int packet_read(SSH_SESSION *session) {
|
||||
int packet_read(ssh_session session) {
|
||||
#ifdef WITH_SSH1
|
||||
if (session->version == 1) {
|
||||
return packet_read1(session);
|
||||
@ -374,7 +374,7 @@ int packet_read(SSH_SESSION *session) {
|
||||
return packet_read2(session);
|
||||
}
|
||||
|
||||
int packet_translate(SSH_SESSION *session) {
|
||||
int packet_translate(ssh_session session) {
|
||||
enter_function();
|
||||
|
||||
memset(&session->in_packet, 0, sizeof(PACKET));
|
||||
@ -405,7 +405,7 @@ int packet_translate(SSH_SESSION *session) {
|
||||
* Return SSH_OK if everything has been sent, SSH_AGAIN if there are still
|
||||
* things to send on buffer, SSH_ERROR if there is an error.
|
||||
*/
|
||||
int packet_flush(SSH_SESSION *session, int enforce_blocking) {
|
||||
int packet_flush(ssh_session session, int enforce_blocking) {
|
||||
if (enforce_blocking || session->blocking) {
|
||||
return ssh_socket_blocking_flush(session->socket);
|
||||
}
|
||||
@ -417,7 +417,7 @@ int packet_flush(SSH_SESSION *session, int enforce_blocking) {
|
||||
* This function places the outgoing packet buffer into an outgoing
|
||||
* socket buffer
|
||||
*/
|
||||
static int packet_write(SSH_SESSION *session) {
|
||||
static int packet_write(ssh_session session) {
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
enter_function();
|
||||
@ -432,7 +432,7 @@ static int packet_write(SSH_SESSION *session) {
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int packet_send2(SSH_SESSION *session) {
|
||||
static int packet_send2(ssh_session session) {
|
||||
unsigned int blocksize = (session->current_crypto ?
|
||||
session->current_crypto->out_cipher->blocksize : 8);
|
||||
uint32_t currentlen = buffer_get_len(session->out_buffer);
|
||||
@ -502,7 +502,7 @@ error:
|
||||
}
|
||||
|
||||
#ifdef WITH_SSH1
|
||||
static int packet_send1(SSH_SESSION *session) {
|
||||
static int packet_send1(ssh_session session) {
|
||||
unsigned int blocksize = (session->current_crypto ?
|
||||
session->current_crypto->out_cipher->blocksize : 8);
|
||||
uint32_t currentlen = buffer_get_len(session->out_buffer) + sizeof(uint32_t);
|
||||
@ -581,7 +581,7 @@ error:
|
||||
|
||||
#endif /* WITH_SSH1 */
|
||||
|
||||
int packet_send(SSH_SESSION *session) {
|
||||
int packet_send(ssh_session session) {
|
||||
#ifdef WITH_SSH1
|
||||
if (session->version == 1) {
|
||||
return packet_send1(session);
|
||||
@ -590,7 +590,7 @@ int packet_send(SSH_SESSION *session) {
|
||||
return packet_send2(session);
|
||||
}
|
||||
|
||||
void packet_parse(SSH_SESSION *session) {
|
||||
void packet_parse(ssh_session session) {
|
||||
ssh_string error_s = NULL;
|
||||
char *error = NULL;
|
||||
uint32_t type = session->in_packet.type;
|
||||
@ -669,7 +669,7 @@ void packet_parse(SSH_SESSION *session) {
|
||||
}
|
||||
|
||||
#ifdef WITH_SSH1
|
||||
static int packet_wait1(SSH_SESSION *session, int type, int blocking) {
|
||||
static int packet_wait1(ssh_session session, int type, int blocking) {
|
||||
|
||||
enter_function();
|
||||
|
||||
@ -726,7 +726,7 @@ static int packet_wait1(SSH_SESSION *session, int type, int blocking) {
|
||||
}
|
||||
#endif /* WITH_SSH1 */
|
||||
|
||||
static int packet_wait2(SSH_SESSION *session, int type, int blocking) {
|
||||
static int packet_wait2(ssh_session session, int type, int blocking) {
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
enter_function();
|
||||
@ -781,7 +781,7 @@ static int packet_wait2(SSH_SESSION *session, int type, int blocking) {
|
||||
return SSH_OK;
|
||||
}
|
||||
|
||||
int packet_wait(SSH_SESSION *session, int type, int block) {
|
||||
int packet_wait(ssh_session session, int type, int block) {
|
||||
#ifdef WITH_SSH1
|
||||
if (session->version == 1) {
|
||||
return packet_wait1(session, type, block);
|
||||
|
@ -176,8 +176,8 @@ void ssh_bind_fd_toaccept(SSH_BIND *ssh_bind) {
|
||||
ssh_bind->toaccept = 1;
|
||||
}
|
||||
|
||||
SSH_SESSION *ssh_bind_accept(SSH_BIND *ssh_bind) {
|
||||
SSH_SESSION *session;
|
||||
ssh_session ssh_bind_accept(SSH_BIND *ssh_bind) {
|
||||
ssh_session session;
|
||||
ssh_private_key dsa = NULL;
|
||||
ssh_private_key rsa = NULL;
|
||||
int fd = -1;
|
||||
@ -269,7 +269,7 @@ void ssh_bind_free(SSH_BIND *ssh_bind){
|
||||
|
||||
extern char *supported_methods[];
|
||||
|
||||
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;
|
||||
@ -323,7 +323,7 @@ static int server_set_kex(SSH_SESSION * session) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dh_handshake_server(SSH_SESSION *session) {
|
||||
static int dh_handshake_server(ssh_session session) {
|
||||
ssh_string e;
|
||||
ssh_string f;
|
||||
ssh_string pubkey;
|
||||
@ -473,7 +473,7 @@ static int dh_handshake_server(SSH_SESSION *session) {
|
||||
}
|
||||
|
||||
/* Do the banner and key exchange */
|
||||
int ssh_accept(SSH_SESSION *session) {
|
||||
int ssh_accept(ssh_session session) {
|
||||
if (ssh_send_banner(session, 1) < 0) {
|
||||
return -1;
|
||||
}
|
||||
@ -529,7 +529,7 @@ int channel_write_stderr(ssh_channel channel, const void *data, uint32_t len) {
|
||||
/* messages */
|
||||
|
||||
static int ssh_message_auth_reply_default(SSH_MESSAGE *msg,int partial) {
|
||||
SSH_SESSION *session = msg->session;
|
||||
ssh_session session = msg->session;
|
||||
char methods_c[128] = {0};
|
||||
ssh_string methods = NULL;
|
||||
int rc = SSH_ERROR;
|
||||
@ -650,7 +650,7 @@ static int ssh_message_service_request_reply_default(SSH_MESSAGE *msg) {
|
||||
|
||||
int ssh_message_service_reply_success(SSH_MESSAGE *msg) {
|
||||
struct ssh_string_struct *service;
|
||||
SSH_SESSION *session=msg->session;
|
||||
ssh_session session=msg->session;
|
||||
if (msg == NULL) {
|
||||
return SSH_ERROR;
|
||||
}
|
||||
@ -828,12 +828,12 @@ char *ssh_message_channel_request_subsystem(SSH_MESSAGE *msg){
|
||||
* 0 if the message has been parsed and treated sucessfuly, 1 otherwise (libssh
|
||||
* must take care of the response).
|
||||
*/
|
||||
void ssh_set_message_callback(SSH_SESSION *session,
|
||||
void ssh_set_message_callback(ssh_session session,
|
||||
int(*ssh_message_callback)(ssh_session session, ssh_message msg)){
|
||||
session->ssh_message_callback=ssh_message_callback;
|
||||
}
|
||||
|
||||
int ssh_execute_message_callbacks(SSH_SESSION *session){
|
||||
int ssh_execute_message_callbacks(ssh_session session){
|
||||
SSH_MESSAGE *msg=NULL;
|
||||
int ret;
|
||||
if(!session->ssh_message_list)
|
||||
|
@ -38,15 +38,14 @@
|
||||
/** \brief creates a new ssh session
|
||||
* \returns new ssh_session pointer
|
||||
*/
|
||||
SSH_SESSION *ssh_new(void) {
|
||||
SSH_SESSION *session;
|
||||
ssh_session ssh_new(void) {
|
||||
ssh_session session;
|
||||
|
||||
session = malloc(sizeof (SSH_SESSION));
|
||||
session = malloc(sizeof (struct ssh_session_struct));
|
||||
if (session == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memset(session, 0, sizeof(SSH_SESSION));
|
||||
ZERO_STRUCTP(session);
|
||||
|
||||
session->next_crypto = crypto_new();
|
||||
if (session->next_crypto == NULL) {
|
||||
@ -87,7 +86,7 @@ err:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void ssh_cleanup(SSH_SESSION *session) {
|
||||
void ssh_cleanup(ssh_session session) {
|
||||
int i;
|
||||
enter_function();
|
||||
|
||||
@ -138,8 +137,7 @@ void ssh_cleanup(SSH_SESSION *session) {
|
||||
ssh_options_free(session->options);
|
||||
|
||||
/* burn connection, it could hang sensitive datas */
|
||||
memset(session,'X',sizeof(SSH_SESSION));
|
||||
|
||||
ZERO_STRUCTP(session);
|
||||
SAFE_FREE(session);
|
||||
/* FIXME: leave_function(); ??? */
|
||||
}
|
||||
@ -147,7 +145,7 @@ void ssh_cleanup(SSH_SESSION *session) {
|
||||
/** \brief disconnect impolitely from remote host
|
||||
* \param session current ssh session
|
||||
*/
|
||||
void ssh_silent_disconnect(SSH_SESSION *session) {
|
||||
void ssh_silent_disconnect(ssh_session session) {
|
||||
enter_function();
|
||||
|
||||
if (session == NULL) {
|
||||
@ -166,7 +164,7 @@ void ssh_silent_disconnect(SSH_SESSION *session) {
|
||||
* \see ssh_new()
|
||||
* \see ssh_options_new()
|
||||
*/
|
||||
void ssh_set_options(SSH_SESSION *session, SSH_OPTIONS *options) {
|
||||
void ssh_set_options(ssh_session session, SSH_OPTIONS *options) {
|
||||
if (session == NULL || options == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -180,7 +178,7 @@ void ssh_set_options(SSH_SESSION *session, SSH_OPTIONS *options) {
|
||||
* \param blocking zero for nonblocking mode
|
||||
* \bug nonblocking code is in development and won't work as expected
|
||||
*/
|
||||
void ssh_set_blocking(SSH_SESSION *session, int blocking) {
|
||||
void ssh_set_blocking(ssh_session session, int blocking) {
|
||||
if (session == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -195,7 +193,7 @@ void ssh_set_blocking(SSH_SESSION *session, int blocking) {
|
||||
* \return file descriptor of the connection, or -1 if it is
|
||||
* not connected
|
||||
*/
|
||||
socket_t ssh_get_fd(SSH_SESSION *session) {
|
||||
socket_t ssh_get_fd(ssh_session session) {
|
||||
if (session == NULL) {
|
||||
return -1;
|
||||
}
|
||||
@ -206,7 +204,7 @@ socket_t ssh_get_fd(SSH_SESSION *session) {
|
||||
/** \brief say to the session it has data to read on the file descriptor without blocking
|
||||
* \param session ssh session
|
||||
*/
|
||||
void ssh_set_fd_toread(SSH_SESSION *session) {
|
||||
void ssh_set_fd_toread(ssh_session session) {
|
||||
if (session == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -217,7 +215,7 @@ void ssh_set_fd_toread(SSH_SESSION *session) {
|
||||
/** \brief say the session it may write to the file descriptor without blocking
|
||||
* \param session ssh session
|
||||
*/
|
||||
void ssh_set_fd_towrite(SSH_SESSION *session) {
|
||||
void ssh_set_fd_towrite(ssh_session session) {
|
||||
if (session == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -228,7 +226,7 @@ void ssh_set_fd_towrite(SSH_SESSION *session) {
|
||||
/** \brief say the session it has an exception to catch on the file descriptor
|
||||
* \param session ssh session
|
||||
*/
|
||||
void ssh_set_fd_except(SSH_SESSION *session) {
|
||||
void ssh_set_fd_except(ssh_session session) {
|
||||
if (session == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -239,7 +237,7 @@ void ssh_set_fd_except(SSH_SESSION *session) {
|
||||
/** \warning I don't remember if this should be internal or not
|
||||
*/
|
||||
/* looks if there is data to read on the socket and parse it. */
|
||||
int ssh_handle_packets(SSH_SESSION *session) {
|
||||
int ssh_handle_packets(ssh_session session) {
|
||||
int w = 0;
|
||||
int e = 0;
|
||||
int rc = -1;
|
||||
@ -277,7 +275,7 @@ int ssh_handle_packets(SSH_SESSION *session) {
|
||||
* which respectively means the session is closed, has data to read on
|
||||
* the connection socket and session was closed due to an error.
|
||||
*/
|
||||
int ssh_get_status(SSH_SESSION *session) {
|
||||
int ssh_get_status(ssh_session session) {
|
||||
int socketstate;
|
||||
int r = 0;
|
||||
|
||||
@ -305,7 +303,7 @@ int ssh_get_status(SSH_SESSION *session) {
|
||||
* \return message sent by the server along with the disconnect, or NULL in which case the reason of the disconnect may be found with ssh_get_error.
|
||||
* \see ssh_get_error()
|
||||
*/
|
||||
const char *ssh_get_disconnect_message(SSH_SESSION *session) {
|
||||
const char *ssh_get_disconnect_message(ssh_session session) {
|
||||
if (session == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
@ -333,7 +331,7 @@ const char *ssh_get_disconnect_message(SSH_SESSION *session) {
|
||||
*
|
||||
* @return 1 or 2, for ssh1 or ssh2, < 0 on error.
|
||||
*/
|
||||
int ssh_get_version(SSH_SESSION *session) {
|
||||
int ssh_get_version(ssh_session session) {
|
||||
if (session == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
@ -95,7 +95,7 @@ static void sftp_ext_free(sftp_ext ext) {
|
||||
SAFE_FREE(ext);
|
||||
}
|
||||
|
||||
SFTP_SESSION *sftp_new(SSH_SESSION *session){
|
||||
SFTP_SESSION *sftp_new(ssh_session session){
|
||||
SFTP_SESSION *sftp;
|
||||
|
||||
enter_function();
|
||||
@ -145,7 +145,7 @@ SFTP_SESSION *sftp_new(SSH_SESSION *session){
|
||||
}
|
||||
|
||||
#ifdef WITH_SERVER
|
||||
SFTP_SESSION *sftp_server_new(SSH_SESSION *session, ssh_channel chan){
|
||||
SFTP_SESSION *sftp_server_new(ssh_session session, ssh_channel chan){
|
||||
SFTP_SESSION *sftp = NULL;
|
||||
|
||||
sftp = malloc(sizeof(SFTP_SESSION));
|
||||
|
@ -49,7 +49,7 @@ struct socket {
|
||||
int data_except;
|
||||
ssh_buffer out_buffer;
|
||||
ssh_buffer in_buffer;
|
||||
SSH_SESSION *session;
|
||||
ssh_session session;
|
||||
};
|
||||
|
||||
/*
|
||||
@ -71,7 +71,7 @@ int ssh_socket_init(void) {
|
||||
* \internal
|
||||
* \brief creates a new Socket object
|
||||
*/
|
||||
struct socket *ssh_socket_new(SSH_SESSION *session) {
|
||||
struct socket *ssh_socket_new(ssh_session session) {
|
||||
struct socket *s;
|
||||
|
||||
s = malloc(sizeof(struct socket));
|
||||
@ -285,7 +285,7 @@ int ssh_socket_completeread(struct socket *s, void *buffer, uint32_t len) {
|
||||
* \brief Blocking write of len bytes
|
||||
*/
|
||||
int ssh_socket_completewrite(struct socket *s, const void *buffer, uint32_t len) {
|
||||
SSH_SESSION *session = s->session;
|
||||
ssh_session session = s->session;
|
||||
int written = -1;
|
||||
|
||||
enter_function();
|
||||
@ -315,7 +315,7 @@ int ssh_socket_completewrite(struct socket *s, const void *buffer, uint32_t len)
|
||||
* \returns SSH_AGAIN in nonblocking mode
|
||||
*/
|
||||
int ssh_socket_read(struct socket *s, void *buffer, int len){
|
||||
SSH_SESSION *session = s->session;
|
||||
ssh_session session = s->session;
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
enter_function();
|
||||
@ -340,7 +340,7 @@ int ssh_socket_read(struct socket *s, void *buffer, int len){
|
||||
* \warning has no effect on socket before a flush
|
||||
*/
|
||||
int ssh_socket_write(struct socket *s, const void *buffer, int len) {
|
||||
SSH_SESSION *session = s->session;
|
||||
ssh_session session = s->session;
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
enter_function();
|
||||
@ -369,7 +369,7 @@ int ssh_socket_write(struct socket *s, const void *buffer, int len) {
|
||||
* \returns SSH_AGAIN need to call later for data
|
||||
* \returns SSH_ERROR error happened
|
||||
*/
|
||||
int ssh_socket_wait_for_data(struct socket *s, SSH_SESSION *session, uint32_t len) {
|
||||
int ssh_socket_wait_for_data(struct socket *s, ssh_session session, uint32_t len) {
|
||||
char buffer[4096] = {0};
|
||||
char *buf = NULL;
|
||||
int except;
|
||||
@ -457,7 +457,7 @@ int ssh_socket_wait_for_data(struct socket *s, SSH_SESSION *session, uint32_t le
|
||||
|
||||
/* ssh_socket_poll */
|
||||
int ssh_socket_poll(struct socket *s, int *writeable, int *except) {
|
||||
SSH_SESSION *session = s->session;
|
||||
ssh_session session = s->session;
|
||||
ssh_pollfd_t fd[1];
|
||||
int rc = -1;
|
||||
|
||||
@ -508,7 +508,7 @@ int ssh_socket_poll(struct socket *s, int *writeable, int *except) {
|
||||
* \brief nonblocking flush of the output buffer
|
||||
*/
|
||||
int ssh_socket_nonblocking_flush(struct socket *s) {
|
||||
SSH_SESSION *session = s->session;
|
||||
ssh_session session = s->session;
|
||||
int except;
|
||||
int can_write;
|
||||
int w;
|
||||
@ -577,7 +577,7 @@ int ssh_socket_nonblocking_flush(struct socket *s) {
|
||||
* \brief locking flush of the output packet buffer
|
||||
*/
|
||||
int ssh_socket_blocking_flush(struct socket *s) {
|
||||
SSH_SESSION *session = s->session;
|
||||
ssh_session session = s->session;
|
||||
|
||||
enter_function();
|
||||
|
||||
|
@ -803,7 +803,7 @@ void crypto_free(CRYPTO *crypto){
|
||||
SAFE_FREE(crypto);
|
||||
}
|
||||
|
||||
static int crypt_set_algorithms2(SSH_SESSION *session){
|
||||
static int crypt_set_algorithms2(ssh_session session){
|
||||
const char *wanted;
|
||||
int i = 0;
|
||||
|
||||
@ -860,7 +860,7 @@ static int crypt_set_algorithms2(SSH_SESSION *session){
|
||||
return SSH_OK;
|
||||
}
|
||||
|
||||
static int crypt_set_algorithms1(SSH_SESSION *session) {
|
||||
static int crypt_set_algorithms1(ssh_session session) {
|
||||
int i = 0;
|
||||
|
||||
/* right now, we force 3des-cbc to be taken */
|
||||
@ -889,13 +889,13 @@ static int crypt_set_algorithms1(SSH_SESSION *session) {
|
||||
return SSH_OK;
|
||||
}
|
||||
|
||||
int crypt_set_algorithms(SSH_SESSION *session) {
|
||||
int crypt_set_algorithms(ssh_session session) {
|
||||
return (session->version == 1) ? crypt_set_algorithms1(session) :
|
||||
crypt_set_algorithms2(session);
|
||||
}
|
||||
|
||||
// TODO Obviously too much cut and paste here
|
||||
int crypt_set_algorithms_server(SSH_SESSION *session){
|
||||
int crypt_set_algorithms_server(ssh_session session){
|
||||
char *server = NULL;
|
||||
char *client = NULL;
|
||||
char *match = NULL;
|
||||
|
14
sample.c
14
sample.c
@ -39,7 +39,7 @@ char *user;
|
||||
int sftp;
|
||||
char *cmds[MAXCMD];
|
||||
struct termios terminal;
|
||||
void do_sftp(SSH_SESSION *session);
|
||||
void do_sftp(ssh_session session);
|
||||
|
||||
static void add_cmd(char *cmd){
|
||||
int n;
|
||||
@ -130,7 +130,7 @@ static void sizechanged(void){
|
||||
// printf("Changed pty size\n");
|
||||
setsignal();
|
||||
}
|
||||
static void select_loop(SSH_SESSION *session,ssh_channel channel){
|
||||
static void select_loop(ssh_session session,ssh_channel channel){
|
||||
fd_set fds;
|
||||
struct timeval timeout;
|
||||
char buffer[10];
|
||||
@ -229,7 +229,7 @@ static void select_loop(SSH_SESSION *session,ssh_channel channel){
|
||||
}
|
||||
|
||||
|
||||
static void shell(SSH_SESSION *session){
|
||||
static void shell(ssh_session session){
|
||||
ssh_channel channel;
|
||||
struct termios terminal_local;
|
||||
int interactive=isatty(0);
|
||||
@ -260,7 +260,7 @@ static void shell(SSH_SESSION *session){
|
||||
select_loop(session,channel);
|
||||
}
|
||||
|
||||
static void batch_shell(SSH_SESSION *session){
|
||||
static void batch_shell(ssh_session session){
|
||||
ssh_channel channel;
|
||||
char buffer[1024];
|
||||
int i,s=0;
|
||||
@ -277,7 +277,7 @@ static void batch_shell(SSH_SESSION *session){
|
||||
|
||||
#ifdef WITH_SFTP
|
||||
/* it's just a proof of concept code for sftp, till i write a real documentation about it */
|
||||
void do_sftp(SSH_SESSION *session){
|
||||
void do_sftp(ssh_session session){
|
||||
SFTP_SESSION *sftp_session=sftp_new(session);
|
||||
SFTP_DIR *dir;
|
||||
SFTP_ATTRIBUTES *file;
|
||||
@ -461,7 +461,7 @@ void do_sftp(SSH_SESSION *session){
|
||||
}
|
||||
#endif
|
||||
|
||||
static int auth_kbdint(SSH_SESSION *session){
|
||||
static int auth_kbdint(ssh_session session){
|
||||
int err=ssh_userauth_kbdint(session,NULL,NULL);
|
||||
const char *name, *instruction, *prompt;
|
||||
char *ptr;
|
||||
@ -501,7 +501,7 @@ static int auth_kbdint(SSH_SESSION *session){
|
||||
}
|
||||
|
||||
int main(int argc, char **argv){
|
||||
SSH_SESSION *session;
|
||||
ssh_session session;
|
||||
SSH_OPTIONS *options;
|
||||
int auth=0;
|
||||
char *password;
|
||||
|
@ -41,7 +41,7 @@ static int auth_password(char *user, char *password){
|
||||
|
||||
int main(int argc, char **argv){
|
||||
SSH_OPTIONS *options=ssh_options_new();
|
||||
SSH_SESSION *session;
|
||||
ssh_session session;
|
||||
SSH_BIND *ssh_bind;
|
||||
SSH_MESSAGE *message;
|
||||
ssh_channel chan=0;
|
||||
|
Загрузка…
x
Ссылка в новой задаче
Block a user