lib/libssh
1
0
Fork 0
mirror of https://git.libssh.org/projects/libssh.git synced 2025-11-29 01:03:57 +03:00
Code Activity

Fixed libssh compilation without server support.

Browse Source
This commit is contained in:
Andreas Schneider
2009-07-31 12:16:25 +02:00
parent 63053541e6
commit 83f65031c0
6 changed files with 392 additions and 392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
include/libssh/libssh.h
View File

@@ -124,13 +124,36 @@ typedef int socket_t;
#define SSH_AUTH_INFO 3 #define SSH_AUTH_INFO 3
#define SSH_AUTH_ERROR -1 #define SSH_AUTH_ERROR -1
#define SSH_AUTH_METHOD_PASSWORD 0x0001 /* auth flags */
#define SSH_AUTH_METHOD_PUBLICKEY 0x0002 #define SSH_AUTH_METHOD_UNKNOWN 0
#define SSH_AUTH_METHOD_HOSTBASED 0x0004 #define SSH_AUTH_METHOD_NONE 0x0001
#define SSH_AUTH_METHOD_INTERACTIVE 0x0008 #define SSH_AUTH_METHOD_PASSWORD 0x0002
#define SSH_AUTH_METHOD_PUBLICKEY 0x0004
#define SSH_AUTH_METHOD_HOSTBASED 0x0008
#define SSH_AUTH_METHOD_INTERACTIVE 0x0010
/* messages */
#define SSH_REQUEST_AUTH 1
#define SSH_REQUEST_CHANNEL_OPEN 2
#define SSH_REQUEST_CHANNEL 3
#define SSH_REQUEST_SERVICE 4
#define SSH_REQUEST_GLOBAL 5
#define SSH_CHANNEL_UNKNOWN 0
#define SSH_CHANNEL_SESSION 1
#define SSH_CHANNEL_DIRECT_TCPIP 2
#define SSH_CHANNEL_FORWARDED_TCPIP 3
#define SSH_CHANNEL_X11 4
#define SSH_CHANNEL_REQUEST_UNKNOWN 0
#define SSH_CHANNEL_REQUEST_PTY 1
#define SSH_CHANNEL_REQUEST_EXEC 2
#define SSH_CHANNEL_REQUEST_SHELL 3
#define SSH_CHANNEL_REQUEST_ENV 4
#define SSH_CHANNEL_REQUEST_SUBSYSTEM 5
#define SSH_CHANNEL_REQUEST_WINDOW_CHANGE 6
/* status flags */ /* status flags */
#define SSH_CLOSED (1<<0) #define SSH_CLOSED (1<<0)
#define SSH_READ_PENDING (1<<1) #define SSH_READ_PENDING (1<<1)
#define SSH_CLOSED_ERROR (1<<2) #define SSH_CLOSED_ERROR (1<<2)
@@ -389,6 +412,19 @@ int ssh_userauth_kbdint_setanswer(SSH_SESSION *session, unsigned int i,
int ssh_init(void); int ssh_init(void);
int ssh_finalize(void); int ssh_finalize(void);
/* messages.c */
typedef struct ssh_message SSH_MESSAGE;
SSH_MESSAGE *ssh_message_retrieve(SSH_SESSION *session, uint32_t packettype);
SSH_MESSAGE *ssh_message_get(SSH_SESSION *session);
int ssh_message_type(SSH_MESSAGE *msg);
int ssh_message_subtype(SSH_MESSAGE *msg);
void ssh_message_free(SSH_MESSAGE *msg);
ssh_channel ssh_message_channel_request_open_reply_accept(SSH_MESSAGE *msg);
int ssh_message_channel_request_reply_success(SSH_MESSAGE *msg);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

37
include/libssh/server.h
View File

@@ -124,41 +124,7 @@ int ssh_accept(SSH_SESSION *session);
int channel_write_stderr(ssh_channel channel, const void *data, uint32_t len); int channel_write_stderr(ssh_channel channel, const void *data, uint32_t len);
/* messages.c */ /* messages.c */
#define SSH_AUTH_REQUEST 1
#define SSH_CHANNEL_REQUEST_OPEN 2
#define SSH_CHANNEL_REQUEST 3
#define SSH_SERVICE_REQUEST 4
#define SSH_AUTH_NONE (1<<0)
#define SSH_AUTH_PASSWORD (1<<1)
#define SSH_AUTH_HOSTBASED (1<<2)
#define SSH_AUTH_PUBLICKEY (1<<3)
#define SSH_AUTH_KEYBINT (1<<4)
#define SSH_AUTH_UNKNOWN 0
#define SSH_CHANNEL_SESSION 1
#define SSH_CHANNEL_DIRECT_TCPIP 2
#define SSH_CHANNEL_FORWARDED_TCPIP 3
#define SSH_CHANNEL_X11 4
#define SSH_CHANNEL_UNKNOWN 5
#define SSH_CHANNEL_REQUEST_PTY 1
#define SSH_CHANNEL_REQUEST_EXEC 2
#define SSH_CHANNEL_REQUEST_SHELL 3
#define SSH_CHANNEL_REQUEST_ENV 4
#define SSH_CHANNEL_REQUEST_SUBSYSTEM 5
#define SSH_CHANNEL_REQUEST_WINDOW_CHANGE 6
#define SSH_CHANNEL_REQUEST_UNKNOWN 7
typedef struct ssh_message SSH_MESSAGE;
SSH_MESSAGE *ssh_message_retrieve(SSH_SESSION *session, uint32_t packettype);
SSH_MESSAGE *ssh_message_get(SSH_SESSION *session);
int ssh_message_type(SSH_MESSAGE *msg);
int ssh_message_subtype(SSH_MESSAGE *msg);
int ssh_message_reply_default(SSH_MESSAGE *msg); int ssh_message_reply_default(SSH_MESSAGE *msg);
void ssh_message_free(SSH_MESSAGE *msg);
char *ssh_message_auth_user(SSH_MESSAGE *msg); char *ssh_message_auth_user(SSH_MESSAGE *msg);
char *ssh_message_auth_password(SSH_MESSAGE *msg); char *ssh_message_auth_password(SSH_MESSAGE *msg);
@@ -167,9 +133,6 @@ int ssh_message_auth_reply_success(SSH_MESSAGE *msg,int partial);
int ssh_message_auth_reply_pk_ok(SSH_MESSAGE *msg, ssh_string algo, ssh_string pubkey); int ssh_message_auth_reply_pk_ok(SSH_MESSAGE *msg, ssh_string algo, ssh_string pubkey);
int ssh_message_auth_set_methods(SSH_MESSAGE *msg, int methods); int ssh_message_auth_set_methods(SSH_MESSAGE *msg, int methods);
ssh_channel ssh_message_channel_request_open_reply_accept(SSH_MESSAGE *msg);
int ssh_message_channel_request_reply_success(SSH_MESSAGE *msg);
int ssh_message_service_reply_success(SSH_MESSAGE *msg); int ssh_message_service_reply_success(SSH_MESSAGE *msg);
char *ssh_message_service_service(SSH_MESSAGE *msg); char *ssh_message_service_service(SSH_MESSAGE *msg);

3
libssh/channels.c
View File

@@ -34,7 +34,6 @@
#include "libssh/priv.h" #include "libssh/priv.h"
#include "libssh/ssh2.h" #include "libssh/ssh2.h"
#include "libssh/server.h"
#define WINDOWBASE 128000 #define WINDOWBASE 128000
#define WINDOWLIMIT (WINDOWBASE/2) #define WINDOWLIMIT (WINDOWBASE/2)
@@ -1360,7 +1359,7 @@ ssh_channel channel_accept_x11(ssh_channel channel, int timeout_ms) {
iterator = ssh_list_get_iterator(session->ssh_message_list); iterator = ssh_list_get_iterator(session->ssh_message_list);
while (iterator) { while (iterator) {
msg = (SSH_MESSAGE*)iterator->data; msg = (SSH_MESSAGE*)iterator->data;
if (ssh_message_type(msg) == SSH_CHANNEL_REQUEST_OPEN && if (ssh_message_type(msg) == SSH_REQUEST_CHANNEL_OPEN &&
ssh_message_subtype(msg) == SSH_CHANNEL_X11) { ssh_message_subtype(msg) == SSH_CHANNEL_X11) {
ssh_list_remove(session->ssh_message_list, iterator); ssh_list_remove(session->ssh_message_list, iterator);
return ssh_message_channel_request_open_reply_accept(msg); return ssh_message_channel_request_open_reply_accept(msg);

356
libssh/messages.c
View File

@@ -41,7 +41,6 @@
#include "libssh/libssh.h" #include "libssh/libssh.h"
#include "libssh/priv.h" #include "libssh/priv.h"
#include "libssh/server.h"
#include "libssh/ssh2.h" #include "libssh/ssh2.h"
@@ -80,44 +79,13 @@ static SSH_MESSAGE *handle_service_request(SSH_SESSION *session) {
SAFE_FREE(service_c); SAFE_FREE(service_c);
goto error; goto error;
} }
msg->type=SSH_SERVICE_REQUEST; msg->type=SSH_REQUEST_SERVICE;
msg->service_request.service=service_c; msg->service_request.service=service_c;
error: error:
leave_function(); leave_function();
return msg; return msg;
} }
static int ssh_message_service_request_reply_default(SSH_MESSAGE *msg) {
/* The only return code accepted by specifications are success or disconnect */
return ssh_message_service_reply_success(msg);
}
int ssh_message_service_reply_success(SSH_MESSAGE *msg) {
struct ssh_string_struct *service;
SSH_SESSION *session=msg->session;
if (msg == NULL) {
return SSH_ERROR;
}
ssh_log(session, SSH_LOG_PACKET,
"Sending a SERVICE_ACCEPT for service %s", msg->service_request.service);
if (buffer_add_u8(session->out_buffer, SSH2_MSG_SERVICE_ACCEPT) < 0) {
return -1;
}
service=string_from_char(msg->service_request.service);
if (buffer_add_ssh_string(session->out_buffer, service) < 0) {
string_free(service);
return -1;
}
string_free(service);
return packet_send(msg->session);
}
char *ssh_message_service_service(SSH_MESSAGE *msg){
if (msg == NULL) {
return NULL;
}
return msg->service_request.service;
}
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) { if (buffer_add_u32(session->out_buffer, htonl(session->recv_seq - 1)) < 0) {
return -1; return -1;
@@ -158,7 +126,7 @@ static SSH_MESSAGE *handle_userauth_request(SSH_SESSION *session){
goto error; goto error;
} }
msg->type = SSH_AUTH_REQUEST; msg->type = SSH_REQUEST_AUTH;
msg->auth_request.username = string_to_char(user); msg->auth_request.username = string_to_char(user);
if (msg->auth_request.username == NULL) { if (msg->auth_request.username == NULL) {
goto error; goto error;
@@ -187,7 +155,7 @@ static SSH_MESSAGE *handle_userauth_request(SSH_SESSION *session){
if (strcmp(method_c, "none") == 0) { if (strcmp(method_c, "none") == 0) {
msg->auth_request.method = SSH_AUTH_NONE; msg->auth_request.method = SSH_AUTH_METHOD_NONE;
SAFE_FREE(service_c); SAFE_FREE(service_c);
SAFE_FREE(method_c); SAFE_FREE(method_c);
leave_function(); leave_function();
@@ -198,7 +166,7 @@ static SSH_MESSAGE *handle_userauth_request(SSH_SESSION *session){
ssh_string pass = NULL; ssh_string pass = NULL;
uint8_t tmp; uint8_t tmp;
msg->auth_request.method = SSH_AUTH_PASSWORD; msg->auth_request.method = SSH_AUTH_METHOD_PASSWORD;
SAFE_FREE(service_c); SAFE_FREE(service_c);
SAFE_FREE(method_c); SAFE_FREE(method_c);
buffer_get_u8(session->in_buffer, &tmp); buffer_get_u8(session->in_buffer, &tmp);
@@ -222,7 +190,7 @@ static SSH_MESSAGE *handle_userauth_request(SSH_SESSION *session){
ssh_string publickey = NULL; ssh_string publickey = NULL;
uint8_t has_sign; uint8_t has_sign;
msg->auth_request.method = SSH_AUTH_PUBLICKEY; msg->auth_request.method = SSH_AUTH_METHOD_PUBLICKEY;
SAFE_FREE(method_c); SAFE_FREE(method_c);
buffer_get_u8(session->in_buffer, &has_sign); buffer_get_u8(session->in_buffer, &has_sign);
algo = buffer_get_ssh_string(session->in_buffer); algo = buffer_get_ssh_string(session->in_buffer);
@@ -277,7 +245,7 @@ static SSH_MESSAGE *handle_userauth_request(SSH_SESSION *session){
return msg; return msg;
} }
msg->auth_request.method = SSH_AUTH_UNKNOWN; msg->auth_request.method = SSH_AUTH_METHOD_UNKNOWN;
SAFE_FREE(method_c); SAFE_FREE(method_c);
leave_function(); leave_function();
@@ -296,133 +264,6 @@ error:
return NULL; return NULL;
} }
char *ssh_message_auth_user(SSH_MESSAGE *msg) {
if (msg == NULL) {
return NULL;
}
return msg->auth_request.username;
}
char *ssh_message_auth_password(SSH_MESSAGE *msg){
if (msg == NULL) {
return NULL;
}
return msg->auth_request.password;
}
/* Get the publickey of an auth request */
ssh_public_key ssh_message_auth_publickey(SSH_MESSAGE *msg){
if (msg == NULL) {
return NULL;
}
return msg->auth_request.public_key;
}
int ssh_message_auth_set_methods(SSH_MESSAGE *msg, int methods) {
if (msg == NULL || msg->session == NULL) {
return -1;
}
msg->session->auth_methods = methods;
return 0;
}
static int ssh_message_auth_reply_default(SSH_MESSAGE *msg,int partial) {
SSH_SESSION *session = msg->session;
char methods_c[128] = {0};
ssh_string methods = NULL;
int rc = SSH_ERROR;
enter_function();
if (buffer_add_u8(session->out_buffer, SSH2_MSG_USERAUTH_FAILURE) < 0) {
return rc;
}
if (session->auth_methods == 0) {
session->auth_methods = SSH_AUTH_PUBLICKEY | SSH_AUTH_PASSWORD;
}
if (session->auth_methods & SSH_AUTH_PUBLICKEY) {
strcat(methods_c, "publickey,");
}
if (session->auth_methods & SSH_AUTH_KEYBINT) {
strcat(methods_c, "keyboard-interactive,");
}
if (session->auth_methods & SSH_AUTH_PASSWORD) {
strcat(methods_c, "password,");
}
if (session->auth_methods & SSH_AUTH_HOSTBASED) {
strcat(methods_c, "hostbased,");
}
/* Strip the comma. */
methods_c[strlen(methods_c) - 1] = '\0'; // strip the comma. We are sure there is at
ssh_log(session, SSH_LOG_PACKET,
"Sending a auth failure. methods that can continue: %s", methods_c);
methods = string_from_char(methods_c);
if (methods == NULL) {
goto error;
}
if (buffer_add_ssh_string(msg->session->out_buffer, methods) < 0) {
goto error;
}
if (partial) {
if (buffer_add_u8(session->out_buffer, 1) < 0) {
goto error;
}
} else {
if (buffer_add_u8(session->out_buffer, 0) < 0) {
goto error;
}
}
rc = packet_send(msg->session);
error:
string_free(methods);
leave_function();
return rc;
}
int ssh_message_auth_reply_success(SSH_MESSAGE *msg, int partial) {
if (msg == NULL) {
return SSH_ERROR;
}
if (partial) {
return ssh_message_auth_reply_default(msg, partial);
}
if (buffer_add_u8(msg->session->out_buffer,SSH2_MSG_USERAUTH_SUCCESS) < 0) {
return SSH_ERROR;
}
return packet_send(msg->session);
}
/* Answer OK to a pubkey auth request */
int ssh_message_auth_reply_pk_ok(SSH_MESSAGE *msg, ssh_string algo, ssh_string pubkey) {
if (msg == NULL) {
return SSH_ERROR;
}
if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_USERAUTH_PK_OK) < 0 ||
buffer_add_ssh_string(msg->session->out_buffer, algo) < 0 ||
buffer_add_ssh_string(msg->session->out_buffer, pubkey) < 0) {
return SSH_ERROR;
}
return packet_send(msg->session);
}
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_MESSAGE *msg = NULL;
ssh_string type = NULL, originator = NULL, destination = NULL; ssh_string type = NULL, originator = NULL, destination = NULL;
@@ -437,7 +278,7 @@ static SSH_MESSAGE *handle_channel_request_open(SSH_SESSION *session) {
return NULL; return NULL;
} }
msg->type = SSH_CHANNEL_REQUEST_OPEN; msg->type = SSH_REQUEST_CHANNEL_OPEN;
type = buffer_get_ssh_string(session->in_buffer); type = buffer_get_ssh_string(session->in_buffer);
if (type == NULL) { if (type == NULL) {
@@ -629,35 +470,6 @@ error:
return NULL; return NULL;
} }
static int ssh_message_channel_request_open_reply_default(SSH_MESSAGE *msg) {
ssh_log(msg->session, SSH_LOG_FUNCTIONS, "Refusing a channel");
if (buffer_add_u8(msg->session->out_buffer
, SSH2_MSG_CHANNEL_OPEN_FAILURE) < 0) {
goto error;
}
if (buffer_add_u32(msg->session->out_buffer,
htonl(msg->channel_request_open.sender)) < 0) {
goto error;
}
if (buffer_add_u32(msg->session->out_buffer,
htonl(SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED)) < 0) {
goto error;
}
/* reason is an empty string */
if (buffer_add_u32(msg->session->out_buffer, 0) < 0) {
goto error;
}
/* language too */
if (buffer_add_u32(msg->session->out_buffer, 0) < 0) {
goto error;
}
return packet_send(msg->session);
error:
return SSH_ERROR;
}
static SSH_MESSAGE *handle_channel_request(SSH_SESSION *session) { static SSH_MESSAGE *handle_channel_request(SSH_SESSION *session) {
SSH_MESSAGE *msg = NULL; SSH_MESSAGE *msg = NULL;
ssh_string type = NULL; ssh_string type = NULL;
@@ -691,7 +503,7 @@ static SSH_MESSAGE *handle_channel_request(SSH_SESSION *session) {
"Received a %s channel_request for channel %d (want_reply=%hhd)", "Received a %s channel_request for channel %d (want_reply=%hhd)",
type_c, channel, want_reply); type_c, channel, want_reply);
msg->type = SSH_CHANNEL_REQUEST; msg->type = SSH_REQUEST_CHANNEL;
msg->channel_request.channel = ssh_channel_from_local(session, channel); msg->channel_request.channel = ssh_channel_from_local(session, channel);
msg->channel_request.want_reply = want_reply; msg->channel_request.want_reply = want_reply;
@@ -852,62 +664,6 @@ error:
return NULL; return NULL;
} }
char *ssh_message_channel_request_open_originator(SSH_MESSAGE *msg){
return msg->channel_request_open.originator;
}
int ssh_message_channel_request_open_originator_port(SSH_MESSAGE *msg){
return msg->channel_request_open.originator_port;
}
char *ssh_message_channel_request_open_destination(SSH_MESSAGE *msg){
return msg->channel_request_open.destination;
}
int ssh_message_channel_request_open_destination_port(SSH_MESSAGE *msg){
return msg->channel_request_open.destination_port;
}
CHANNEL *ssh_message_channel_request_channel(SSH_MESSAGE *msg){
return msg->channel_request.channel;
}
char *ssh_message_channel_request_pty_term(SSH_MESSAGE *msg){
return msg->channel_request.TERM;
}
int ssh_message_channel_request_pty_width(SSH_MESSAGE *msg){
return msg->channel_request.width;
}
int ssh_message_channel_request_pty_height(SSH_MESSAGE *msg){
return msg->channel_request.height;
}
int ssh_message_channel_request_pty_pxwidth(SSH_MESSAGE *msg){
return msg->channel_request.pxwidth;
}
int ssh_message_channel_request_pty_pxheight(SSH_MESSAGE *msg){
return msg->channel_request.pxheight;
}
char *ssh_message_channel_request_env_name(SSH_MESSAGE *msg){
return msg->channel_request.var_name;
}
char *ssh_message_channel_request_env_value(SSH_MESSAGE *msg){
return msg->channel_request.var_value;
}
char *ssh_message_channel_request_command(SSH_MESSAGE *msg){
return msg->channel_request.command;
}
char *ssh_message_channel_request_subsystem(SSH_MESSAGE *msg){
return msg->channel_request.subsystem;
}
int ssh_message_channel_request_reply_success(SSH_MESSAGE *msg) { int ssh_message_channel_request_reply_success(SSH_MESSAGE *msg) {
uint32_t channel; uint32_t channel;
@@ -937,31 +693,6 @@ int ssh_message_channel_request_reply_success(SSH_MESSAGE *msg) {
return SSH_OK; return SSH_OK;
} }
static int ssh_message_channel_request_reply_default(SSH_MESSAGE *msg) {
uint32_t channel;
if (msg->channel_request.want_reply) {
channel = msg->channel_request.channel->remote_channel;
ssh_log(msg->session, SSH_LOG_PACKET,
"Sending a default channel_request denied to channel %d", channel);
if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_CHANNEL_FAILURE) < 0) {
return SSH_ERROR;
}
if (buffer_add_u32(msg->session->out_buffer, htonl(channel)) < 0) {
return SSH_ERROR;
}
return packet_send(msg->session);
}
ssh_log(msg->session, SSH_LOG_PACKET,
"The client doesn't want to know the request failed!");
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; SSH_MESSAGE *msg=NULL;
enter_function(); enter_function();
@@ -1020,48 +751,24 @@ int ssh_message_subtype(SSH_MESSAGE *msg) {
} }
switch(msg->type) { switch(msg->type) {
case SSH_AUTH_REQUEST: case SSH_REQUEST_AUTH:
return msg->auth_request.method; return msg->auth_request.method;
case SSH_CHANNEL_REQUEST_OPEN: case SSH_REQUEST_CHANNEL_OPEN:
return msg->channel_request_open.type; return msg->channel_request_open.type;
case SSH_CHANNEL_REQUEST: case SSH_REQUEST_CHANNEL:
return msg->channel_request.type; return msg->channel_request.type;
} }
return -1; return -1;
} }
int ssh_message_reply_default(SSH_MESSAGE *msg) {
if (msg == NULL) {
return -1;
}
switch(msg->type) {
case SSH_AUTH_REQUEST:
return ssh_message_auth_reply_default(msg, 0);
case SSH_CHANNEL_REQUEST_OPEN:
return ssh_message_channel_request_open_reply_default(msg);
case SSH_CHANNEL_REQUEST:
return ssh_message_channel_request_reply_default(msg);
case SSH_SERVICE_REQUEST:
return ssh_message_service_request_reply_default(msg);
default:
ssh_log(msg->session, SSH_LOG_PACKET,
"Don't know what to default reply to %d type",
msg->type);
break;
}
return -1;
}
void ssh_message_free(SSH_MESSAGE *msg){ void ssh_message_free(SSH_MESSAGE *msg){
if (msg == NULL) { if (msg == NULL) {
return; return;
} }
switch(msg->type) { switch(msg->type) {
case SSH_AUTH_REQUEST: case SSH_REQUEST_AUTH:
SAFE_FREE(msg->auth_request.username); SAFE_FREE(msg->auth_request.username);
if (msg->auth_request.password) { if (msg->auth_request.password) {
memset(msg->auth_request.password, 0, memset(msg->auth_request.password, 0,
@@ -1069,11 +776,11 @@ void ssh_message_free(SSH_MESSAGE *msg){
SAFE_FREE(msg->auth_request.password); SAFE_FREE(msg->auth_request.password);
} }
break; break;
case SSH_CHANNEL_REQUEST_OPEN: case SSH_REQUEST_CHANNEL_OPEN:
SAFE_FREE(msg->channel_request_open.originator); SAFE_FREE(msg->channel_request_open.originator);
SAFE_FREE(msg->channel_request_open.destination); SAFE_FREE(msg->channel_request_open.destination);
break; break;
case SSH_CHANNEL_REQUEST: case SSH_REQUEST_CHANNEL:
SAFE_FREE(msg->channel_request.TERM); SAFE_FREE(msg->channel_request.TERM);
SAFE_FREE(msg->channel_request.modes); SAFE_FREE(msg->channel_request.modes);
SAFE_FREE(msg->channel_request.var_name); SAFE_FREE(msg->channel_request.var_name);
@@ -1102,41 +809,6 @@ void message_handle(SSH_SESSION *session, uint32_t type){
} }
} }
/** @brief defines the SSH_MESSAGE callback
* @param session the current ssh session
* @param ssh_message_callback a function pointer to a callback taking the
* current ssh session and received message as parameters. the function returns
* 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,
int(*ssh_message_callback)(ssh_session session, struct ssh_message *msg)){
session->ssh_message_callback=ssh_message_callback;
}
int ssh_execute_message_callbacks(SSH_SESSION *session){
SSH_MESSAGE *msg=NULL;
int ret;
if(!session->ssh_message_list)
return SSH_OK;
if(session->ssh_message_callback){
while((msg=ssh_list_get_head(SSH_MESSAGE *, session->ssh_message_list)) != NULL){
ret=session->ssh_message_callback(session,msg);
if(ret==1){
ret = ssh_message_reply_default(msg);
if(ret != SSH_OK)
return ret;
}
}
} else {
while((msg=ssh_list_get_head(SSH_MESSAGE *, session->ssh_message_list)) != NULL){
ret = ssh_message_reply_default(msg);
if(ret != SSH_OK)
return ret;
}
}
return SSH_OK;
}
/** /**
* @} * @}
*/ */

330
libssh/server.c
View File

@@ -526,6 +526,336 @@ int channel_write_stderr(ssh_channel channel, const void *data, uint32_t len) {
return channel_write_common(channel, data, len, 1); return channel_write_common(channel, data, len, 1);
} }
/* messages */
static int ssh_message_auth_reply_default(SSH_MESSAGE *msg,int partial) {
SSH_SESSION *session = msg->session;
char methods_c[128] = {0};
ssh_string methods = NULL;
int rc = SSH_ERROR;
enter_function();
if (buffer_add_u8(session->out_buffer, SSH2_MSG_USERAUTH_FAILURE) < 0) {
return rc;
}
if (session->auth_methods == 0) {
session->auth_methods = SSH_AUTH_METHOD_PUBLICKEY | SSH_AUTH_METHOD_PASSWORD;
}
if (session->auth_methods & SSH_AUTH_METHOD_PUBLICKEY) {
strcat(methods_c, "publickey,");
}
if (session->auth_methods & SSH_AUTH_METHOD_INTERACTIVE) {
strcat(methods_c, "keyboard-interactive,");
}
if (session->auth_methods & SSH_AUTH_METHOD_PASSWORD) {
strcat(methods_c, "password,");
}
if (session->auth_methods & SSH_AUTH_METHOD_HOSTBASED) {
strcat(methods_c, "hostbased,");
}
/* Strip the comma. */
methods_c[strlen(methods_c) - 1] = '\0'; // strip the comma. We are sure there is at
ssh_log(session, SSH_LOG_PACKET,
"Sending a auth failure. methods that can continue: %s", methods_c);
methods = string_from_char(methods_c);
if (methods == NULL) {
goto error;
}
if (buffer_add_ssh_string(msg->session->out_buffer, methods) < 0) {
goto error;
}
if (partial) {
if (buffer_add_u8(session->out_buffer, 1) < 0) {
goto error;
}
} else {
if (buffer_add_u8(session->out_buffer, 0) < 0) {
goto error;
}
}
rc = packet_send(msg->session);
error:
string_free(methods);
leave_function();
return rc;
}
static int ssh_message_channel_request_open_reply_default(SSH_MESSAGE *msg) {
ssh_log(msg->session, SSH_LOG_FUNCTIONS, "Refusing a channel");
if (buffer_add_u8(msg->session->out_buffer
, SSH2_MSG_CHANNEL_OPEN_FAILURE) < 0) {
goto error;
}
if (buffer_add_u32(msg->session->out_buffer,
htonl(msg->channel_request_open.sender)) < 0) {
goto error;
}
if (buffer_add_u32(msg->session->out_buffer,
htonl(SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED)) < 0) {
goto error;
}
/* reason is an empty string */
if (buffer_add_u32(msg->session->out_buffer, 0) < 0) {
goto error;
}
/* language too */
if (buffer_add_u32(msg->session->out_buffer, 0) < 0) {
goto error;
}
return packet_send(msg->session);
error:
return SSH_ERROR;
}
static int ssh_message_channel_request_reply_default(SSH_MESSAGE *msg) {
uint32_t channel;
if (msg->channel_request.want_reply) {
channel = msg->channel_request.channel->remote_channel;
ssh_log(msg->session, SSH_LOG_PACKET,
"Sending a default channel_request denied to channel %d", channel);
if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_CHANNEL_FAILURE) < 0) {
return SSH_ERROR;
}
if (buffer_add_u32(msg->session->out_buffer, htonl(channel)) < 0) {
return SSH_ERROR;
}
return packet_send(msg->session);
}
ssh_log(msg->session, SSH_LOG_PACKET,
"The client doesn't want to know the request failed!");
return SSH_OK;
}
static int ssh_message_service_request_reply_default(SSH_MESSAGE *msg) {
/* The only return code accepted by specifications are success or disconnect */
return ssh_message_service_reply_success(msg);
}
int ssh_message_service_reply_success(SSH_MESSAGE *msg) {
struct ssh_string_struct *service;
SSH_SESSION *session=msg->session;
if (msg == NULL) {
return SSH_ERROR;
}
ssh_log(session, SSH_LOG_PACKET,
"Sending a SERVICE_ACCEPT for service %s", msg->service_request.service);
if (buffer_add_u8(session->out_buffer, SSH2_MSG_SERVICE_ACCEPT) < 0) {
return -1;
}
service=string_from_char(msg->service_request.service);
if (buffer_add_ssh_string(session->out_buffer, service) < 0) {
string_free(service);
return -1;
}
string_free(service);
return packet_send(msg->session);
}
int ssh_message_reply_default(SSH_MESSAGE *msg) {
if (msg == NULL) {
return -1;
}
switch(msg->type) {
case SSH_REQUEST_AUTH:
return ssh_message_auth_reply_default(msg, 0);
case SSH_REQUEST_CHANNEL_OPEN:
return ssh_message_channel_request_open_reply_default(msg);
case SSH_REQUEST_CHANNEL:
return ssh_message_channel_request_reply_default(msg);
case SSH_REQUEST_SERVICE:
return ssh_message_service_request_reply_default(msg);
default:
ssh_log(msg->session, SSH_LOG_PACKET,
"Don't know what to default reply to %d type",
msg->type);
break;
}
return -1;
}
char *ssh_message_service_service(SSH_MESSAGE *msg){
if (msg == NULL) {
return NULL;
}
return msg->service_request.service;
}
char *ssh_message_auth_user(SSH_MESSAGE *msg) {
if (msg == NULL) {
return NULL;
}
return msg->auth_request.username;
}
char *ssh_message_auth_password(SSH_MESSAGE *msg){
if (msg == NULL) {
return NULL;
}
return msg->auth_request.password;
}
/* Get the publickey of an auth request */
ssh_public_key ssh_message_auth_publickey(SSH_MESSAGE *msg){
if (msg == NULL) {
return NULL;
}
return msg->auth_request.public_key;
}
int ssh_message_auth_set_methods(SSH_MESSAGE *msg, int methods) {
if (msg == NULL || msg->session == NULL) {
return -1;
}
msg->session->auth_methods = methods;
return 0;
}
int ssh_message_auth_reply_success(SSH_MESSAGE *msg, int partial) {
if (msg == NULL) {
return SSH_ERROR;
}
if (partial) {
return ssh_message_auth_reply_default(msg, partial);
}
if (buffer_add_u8(msg->session->out_buffer,SSH2_MSG_USERAUTH_SUCCESS) < 0) {
return SSH_ERROR;
}
return packet_send(msg->session);
}
/* Answer OK to a pubkey auth request */
int ssh_message_auth_reply_pk_ok(SSH_MESSAGE *msg, ssh_string algo, ssh_string pubkey) {
if (msg == NULL) {
return SSH_ERROR;
}
if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_USERAUTH_PK_OK) < 0 ||
buffer_add_ssh_string(msg->session->out_buffer, algo) < 0 ||
buffer_add_ssh_string(msg->session->out_buffer, pubkey) < 0) {
return SSH_ERROR;
}
return packet_send(msg->session);
}
char *ssh_message_channel_request_open_originator(SSH_MESSAGE *msg){
return msg->channel_request_open.originator;
}
int ssh_message_channel_request_open_originator_port(SSH_MESSAGE *msg){
return msg->channel_request_open.originator_port;
}
char *ssh_message_channel_request_open_destination(SSH_MESSAGE *msg){
return msg->channel_request_open.destination;
}
int ssh_message_channel_request_open_destination_port(SSH_MESSAGE *msg){
return msg->channel_request_open.destination_port;
}
CHANNEL *ssh_message_channel_request_channel(SSH_MESSAGE *msg){
return msg->channel_request.channel;
}
char *ssh_message_channel_request_pty_term(SSH_MESSAGE *msg){
return msg->channel_request.TERM;
}
int ssh_message_channel_request_pty_width(SSH_MESSAGE *msg){
return msg->channel_request.width;
}
int ssh_message_channel_request_pty_height(SSH_MESSAGE *msg){
return msg->channel_request.height;
}
int ssh_message_channel_request_pty_pxwidth(SSH_MESSAGE *msg){
return msg->channel_request.pxwidth;
}
int ssh_message_channel_request_pty_pxheight(SSH_MESSAGE *msg){
return msg->channel_request.pxheight;
}
char *ssh_message_channel_request_env_name(SSH_MESSAGE *msg){
return msg->channel_request.var_name;
}
char *ssh_message_channel_request_env_value(SSH_MESSAGE *msg){
return msg->channel_request.var_value;
}
char *ssh_message_channel_request_command(SSH_MESSAGE *msg){
return msg->channel_request.command;
}
char *ssh_message_channel_request_subsystem(SSH_MESSAGE *msg){
return msg->channel_request.subsystem;
}
/** @brief defines the SSH_MESSAGE callback
* @param session the current ssh session
* @param ssh_message_callback a function pointer to a callback taking the
* current ssh session and received message as parameters. the function returns
* 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,
int(*ssh_message_callback)(ssh_session session, struct ssh_message *msg)){
session->ssh_message_callback=ssh_message_callback;
}
int ssh_execute_message_callbacks(SSH_SESSION *session){
SSH_MESSAGE *msg=NULL;
int ret;
if(!session->ssh_message_list)
return SSH_OK;
if(session->ssh_message_callback){
while((msg=ssh_list_get_head(SSH_MESSAGE *, session->ssh_message_list)) != NULL){
ret=session->ssh_message_callback(session,msg);
if(ret==1){
ret = ssh_message_reply_default(msg);
if(ret != SSH_OK)
return ret;
}
}
} else {
while((msg=ssh_list_get_head(SSH_MESSAGE *, session->ssh_message_list)) != NULL){
ret = ssh_message_reply_default(msg);
if(ret != SSH_OK)
return ret;
}
}
return SSH_OK;
}
/** @} /** @}
*/ */
/* vim: set ts=2 sw=2 et cindent: */ /* vim: set ts=2 sw=2 et cindent: */

12
samplesshd.c
View File

@@ -73,9 +73,9 @@ int main(int argc, char **argv){
if(!message) if(!message)
break; break;
switch(ssh_message_type(message)){ switch(ssh_message_type(message)){
case SSH_AUTH_REQUEST: case SSH_REQUEST_AUTH:
switch(ssh_message_subtype(message)){ switch(ssh_message_subtype(message)){
case SSH_AUTH_PASSWORD: case SSH_AUTH_METHOD_PASSWORD:
printf("User %s wants to auth with pass %s\n", printf("User %s wants to auth with pass %s\n",
ssh_message_auth_user(message), ssh_message_auth_user(message),
ssh_message_auth_password(message)); ssh_message_auth_password(message));
@@ -86,9 +86,9 @@ int main(int argc, char **argv){
break; break;
} }
// not authenticated, send default message // not authenticated, send default message
case SSH_AUTH_NONE: case SSH_AUTH_METHOD_NONE:
default: default:
ssh_message_auth_set_methods(message,SSH_AUTH_PASSWORD); ssh_message_auth_set_methods(message,SSH_AUTH_METHOD_PASSWORD);
ssh_message_reply_default(message); ssh_message_reply_default(message);
break; break;
} }
@@ -107,7 +107,7 @@ int main(int argc, char **argv){
message=ssh_message_get(session); message=ssh_message_get(session);
if(message){ if(message){
switch(ssh_message_type(message)){ switch(ssh_message_type(message)){
case SSH_CHANNEL_REQUEST_OPEN: case SSH_REQUEST_CHANNEL_OPEN:
if(ssh_message_subtype(message)==SSH_CHANNEL_SESSION){ if(ssh_message_subtype(message)==SSH_CHANNEL_SESSION){
chan=ssh_message_channel_request_open_reply_accept(message); chan=ssh_message_channel_request_open_reply_accept(message);
break; break;
@@ -125,7 +125,7 @@ int main(int argc, char **argv){
} }
do { do {
message=ssh_message_get(session); message=ssh_message_get(session);
if(message && ssh_message_type(message)==SSH_CHANNEL_REQUEST && if(message && ssh_message_type(message)==SSH_REQUEST_CHANNEL &&
ssh_message_subtype(message)==SSH_CHANNEL_REQUEST_SHELL){ ssh_message_subtype(message)==SSH_CHANNEL_REQUEST_SHELL){
// if(!strcmp(ssh_message_channel_request_subsystem(message),"sftp")){ // if(!strcmp(ssh_message_channel_request_subsystem(message),"sftp")){
sftp=1; sftp=1;