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

src: Migrate to SSH_LOG.

Browse Source
This commit is contained in:
Andreas Schneider
2013-07-14 12:29:45 +02:00
parent dcd94de076
commit ebdd0c6ac1
26 changed files with 268 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/libssh/kex.h
View File

@ -37,7 +37,7 @@ SSH_PACKET_CALLBACK(ssh_packet_publickey1);
#endif #endif
int ssh_send_kex(ssh_session session, int server_kex); int ssh_send_kex(ssh_session session, int server_kex);
void ssh_list_kex(ssh_session session, struct ssh_kex_struct *kex); void ssh_list_kex(struct ssh_kex_struct *kex);
int set_client_kex(ssh_session session); int set_client_kex(ssh_session session);
int ssh_kex_select_methods(ssh_session session); int ssh_kex_select_methods(ssh_session session);
int verify_existing_algo(int algo, const char *name); int verify_existing_algo(int algo, const char *name);

2
src/auth1.c
View File

@ -51,7 +51,7 @@ static int wait_auth1_status(ssh_session session) {
leave_function(); leave_function();
return SSH_AUTH_ERROR; return SSH_AUTH_ERROR;
} }
ssh_log(session,SSH_LOG_PROTOCOL,"Auth state : %d",session->auth_state); SSH_LOG(SSH_LOG_PROTOCOL,"Auth state : %d",session->auth_state);
leave_function(); leave_function();
switch(session->auth_state) { switch(session->auth_state) {
case SSH_AUTH_STATE_SUCCESS: case SSH_AUTH_STATE_SUCCESS:

112
src/channels.c
View File

@ -144,7 +144,7 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open_conf){
(void)type; (void)type;
(void)user; (void)user;
enter_function(); enter_function();
ssh_log(session,SSH_LOG_PACKET,"Received SSH2_MSG_CHANNEL_OPEN_CONFIRMATION"); SSH_LOG(SSH_LOG_PACKET,"Received SSH2_MSG_CHANNEL_OPEN_CONFIRMATION");
buffer_get_u32(packet, &channelid); buffer_get_u32(packet, &channelid);
channelid=ntohl(channelid); channelid=ntohl(channelid);
@ -167,11 +167,11 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open_conf){
buffer_get_u32(packet,&tmp); buffer_get_u32(packet,&tmp);
channel->remote_maxpacket=ntohl(tmp); channel->remote_maxpacket=ntohl(tmp);
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Received a CHANNEL_OPEN_CONFIRMATION for channel %d:%d", "Received a CHANNEL_OPEN_CONFIRMATION for channel %d:%d",
channel->local_channel, channel->local_channel,
channel->remote_channel); channel->remote_channel);
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Remote window : %lu, maxpacket : %lu", "Remote window : %lu, maxpacket : %lu",
(long unsigned int) channel->remote_window, (long unsigned int) channel->remote_window,
(long unsigned int) channel->remote_maxpacket); (long unsigned int) channel->remote_maxpacket);
@ -197,7 +197,7 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open_fail){
(void)type; (void)type;
channel=channel_from_msg(session,packet); channel=channel_from_msg(session,packet);
if(channel==NULL){ if(channel==NULL){
ssh_log(session,SSH_LOG_RARE,"Invalid channel in packet"); SSH_LOG(SSH_LOG_RARE,"Invalid channel in packet");
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
buffer_get_u32(packet, &code); buffer_get_u32(packet, &code);
@ -271,7 +271,7 @@ static int channel_open(ssh_channel channel, const char *type_c, int window,
channel->local_maxpacket = maxpacket; channel->local_maxpacket = maxpacket;
channel->local_window = window; channel->local_window = window;
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Creating a channel %d with %d window and %d max packet", "Creating a channel %d with %d window and %d max packet",
channel->local_channel, window, maxpacket); channel->local_channel, window, maxpacket);
@ -308,7 +308,7 @@ static int channel_open(ssh_channel channel, const char *type_c, int window,
return err; return err;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sent a SSH_MSG_CHANNEL_OPEN type %s for channel %d", "Sent a SSH_MSG_CHANNEL_OPEN type %s for channel %d",
type_c, channel->local_channel); type_c, channel->local_channel);
pending: pending:
@ -360,7 +360,7 @@ static int grow_window(ssh_session session, ssh_channel channel, int minimumsize
} }
#endif #endif
if(new_window <= channel->local_window){ if(new_window <= channel->local_window){
ssh_log(session,SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"growing window (channel %d:%d) to %d bytes : not needed (%d bytes)", "growing window (channel %d:%d) to %d bytes : not needed (%d bytes)",
channel->local_channel, channel->remote_channel, new_window, channel->local_channel, channel->remote_channel, new_window,
channel->local_window); channel->local_window);
@ -381,7 +381,7 @@ static int grow_window(ssh_session session, ssh_channel channel, int minimumsize
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"growing window (channel %d:%d) to %d bytes", "growing window (channel %d:%d) to %d bytes",
channel->local_channel, channel->local_channel,
channel->remote_channel, channel->remote_channel,
@ -447,19 +447,19 @@ SSH_PACKET_CALLBACK(channel_rcv_change_window) {
channel = channel_from_msg(session,packet); channel = channel_from_msg(session,packet);
if (channel == NULL) { if (channel == NULL) {
ssh_log(session, SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session)); SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));
} }
rc = buffer_get_u32(packet, &bytes); rc = buffer_get_u32(packet, &bytes);
if (channel == NULL || rc != sizeof(uint32_t)) { if (channel == NULL || rc != sizeof(uint32_t)) {
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Error getting a window adjust message: invalid packet"); "Error getting a window adjust message: invalid packet");
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
bytes = ntohl(bytes); bytes = ntohl(bytes);
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Adding %d bytes to channel (%d:%d) (from %d bytes)", "Adding %d bytes to channel (%d:%d) (from %d bytes)",
bytes, bytes,
channel->local_channel, channel->local_channel,
@ -489,7 +489,7 @@ SSH_PACKET_CALLBACK(channel_rcv_data){
channel = channel_from_msg(session,packet); channel = channel_from_msg(session,packet);
if (channel == NULL) { if (channel == NULL) {
ssh_log(session, SSH_LOG_FUNCTIONS, SSH_LOG(SSH_LOG_FUNCTIONS,
"%s", ssh_get_error(session)); "%s", ssh_get_error(session));
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
@ -503,13 +503,13 @@ SSH_PACKET_CALLBACK(channel_rcv_data){
str = buffer_get_ssh_string(packet); str = buffer_get_ssh_string(packet);
if (str == NULL) { if (str == NULL) {
ssh_log(session, SSH_LOG_PACKET, "Invalid data packet!"); SSH_LOG(SSH_LOG_PACKET, "Invalid data packet!");
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
len = ssh_string_len(str); len = ssh_string_len(str);
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Channel receiving %" PRIdS " bytes data in %d (local win=%d remote win=%d)", "Channel receiving %" PRIdS " bytes data in %d (local win=%d remote win=%d)",
len, len,
is_stderr, is_stderr,
@ -518,7 +518,7 @@ SSH_PACKET_CALLBACK(channel_rcv_data){
/* What shall we do in this case? Let's accept it anyway */ /* What shall we do in this case? Let's accept it anyway */
if (len > channel->local_window) { if (len > channel->local_window) {
ssh_log(session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"Data packet too big for our window(%" PRIdS " vs %d)", "Data packet too big for our window(%" PRIdS " vs %d)",
len, len,
channel->local_window); channel->local_window);
@ -537,7 +537,7 @@ SSH_PACKET_CALLBACK(channel_rcv_data){
channel->local_window = 0; /* buggy remote */ channel->local_window = 0; /* buggy remote */
} }
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Channel windows are now (local win=%d remote win=%d)", "Channel windows are now (local win=%d remote win=%d)",
channel->local_window, channel->local_window,
channel->remote_window); channel->remote_window);
@ -579,12 +579,12 @@ SSH_PACKET_CALLBACK(channel_rcv_eof) {
channel = channel_from_msg(session,packet); channel = channel_from_msg(session,packet);
if (channel == NULL) { if (channel == NULL) {
ssh_log(session, SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session)); SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Received eof on channel (%d:%d)", "Received eof on channel (%d:%d)",
channel->local_channel, channel->local_channel,
channel->remote_channel); channel->remote_channel);
@ -609,12 +609,12 @@ SSH_PACKET_CALLBACK(channel_rcv_close) {
channel = channel_from_msg(session,packet); channel = channel_from_msg(session,packet);
if (channel == NULL) { if (channel == NULL) {
ssh_log(session, SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session)); SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Received close on channel (%d:%d)", "Received close on channel (%d:%d)",
channel->local_channel, channel->local_channel,
channel->remote_channel); channel->remote_channel);
@ -628,7 +628,7 @@ SSH_PACKET_CALLBACK(channel_rcv_close) {
channel->state = SSH_CHANNEL_STATE_CLOSED; channel->state = SSH_CHANNEL_STATE_CLOSED;
} }
if (channel->remote_eof == 0) { if (channel->remote_eof == 0) {
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Remote host not polite enough to send an eof before close"); "Remote host not polite enough to send an eof before close");
} }
channel->remote_eof = 1; channel->remote_eof = 1;
@ -662,14 +662,14 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
channel = channel_from_msg(session,packet); channel = channel_from_msg(session,packet);
if (channel == NULL) { if (channel == NULL) {
ssh_log(session, SSH_LOG_FUNCTIONS,"%s", ssh_get_error(session)); SSH_LOG(SSH_LOG_FUNCTIONS,"%s", ssh_get_error(session));
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
request_s = buffer_get_ssh_string(packet); request_s = buffer_get_ssh_string(packet);
if (request_s == NULL) { if (request_s == NULL) {
ssh_log(session, SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST"); SSH_LOG(SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST");
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
@ -689,7 +689,7 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
SAFE_FREE(request); SAFE_FREE(request);
buffer_get_u32(packet, &exit_status); buffer_get_u32(packet, &exit_status);
channel->exit_status = ntohl(exit_status); channel->exit_status = ntohl(exit_status);
ssh_log(session, SSH_LOG_PACKET, "received exit-status %d", channel->exit_status); SSH_LOG(SSH_LOG_PACKET, "received exit-status %d", channel->exit_status);
if(ssh_callbacks_exists(channel->callbacks, channel_exit_status_function)) { if(ssh_callbacks_exists(channel->callbacks, channel_exit_status_function)) {
channel->callbacks->channel_exit_status_function(channel->session, channel->callbacks->channel_exit_status_function(channel->session,
@ -707,11 +707,11 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
char *sig; char *sig;
SAFE_FREE(request); SAFE_FREE(request);
ssh_log(session, SSH_LOG_PACKET, "received signal"); SSH_LOG(SSH_LOG_PACKET, "received signal");
signal_str = buffer_get_ssh_string(packet); signal_str = buffer_get_ssh_string(packet);
if (signal_str == NULL) { if (signal_str == NULL) {
ssh_log(session, SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST"); SSH_LOG(SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST");
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
@ -724,7 +724,7 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Remote connection sent a signal SIG %s", sig); "Remote connection sent a signal SIG %s", sig);
if(ssh_callbacks_exists(channel->callbacks, channel_signal_function)) { if(ssh_callbacks_exists(channel->callbacks, channel_signal_function)) {
channel->callbacks->channel_signal_function(channel->session, channel->callbacks->channel_signal_function(channel->session,
@ -750,7 +750,7 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
tmp = buffer_get_ssh_string(packet); tmp = buffer_get_ssh_string(packet);
if (tmp == NULL) { if (tmp == NULL) {
ssh_log(session, SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST"); SSH_LOG(SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST");
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
@ -769,7 +769,7 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
tmp = buffer_get_ssh_string(packet); tmp = buffer_get_ssh_string(packet);
if (tmp == NULL) { if (tmp == NULL) {
ssh_log(session, SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST"); SSH_LOG(SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST");
SAFE_FREE(sig); SAFE_FREE(sig);
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
@ -785,7 +785,7 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
tmp = buffer_get_ssh_string(packet); tmp = buffer_get_ssh_string(packet);
if (tmp == NULL) { if (tmp == NULL) {
ssh_log(session, SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST"); SSH_LOG(SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST");
SAFE_FREE(errmsg); SAFE_FREE(errmsg);
SAFE_FREE(sig); SAFE_FREE(sig);
leave_function(); leave_function();
@ -801,7 +801,7 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Remote connection closed by signal SIG %s %s", sig, core); "Remote connection closed by signal SIG %s %s", sig, core);
if(ssh_callbacks_exists(channel->callbacks, channel_exit_signal_function)) { if(ssh_callbacks_exists(channel->callbacks, channel_exit_signal_function)) {
channel->callbacks->channel_exit_signal_function(channel->session, channel->callbacks->channel_exit_signal_function(channel->session,
@ -819,7 +819,7 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
} }
if(strcmp(request,"keepalive@openssh.com")==0){ if(strcmp(request,"keepalive@openssh.com")==0){
SAFE_FREE(request); SAFE_FREE(request);
ssh_log(session, SSH_LOG_PROTOCOL,"Responding to Openssh's keepalive"); SSH_LOG(SSH_LOG_PROTOCOL,"Responding to Openssh's keepalive");
rc = buffer_add_u8(session->out_buffer, SSH2_MSG_CHANNEL_FAILURE); rc = buffer_add_u8(session->out_buffer, SSH2_MSG_CHANNEL_FAILURE);
if (rc < 0) { if (rc < 0) {
return SSH_PACKET_USED; return SSH_PACKET_USED;
@ -835,7 +835,7 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
if (strcmp(request, "auth-agent-req@openssh.com") == 0) { if (strcmp(request, "auth-agent-req@openssh.com") == 0) {
SAFE_FREE(request); SAFE_FREE(request);
ssh_log(session, SSH_LOG_PROTOCOL, "Received an auth-agent-req request"); SSH_LOG(SSH_LOG_PROTOCOL, "Received an auth-agent-req request");
if(ssh_callbacks_exists(channel->callbacks, channel_auth_agent_req_function)) { if(ssh_callbacks_exists(channel->callbacks, channel_auth_agent_req_function)) {
channel->callbacks->channel_auth_agent_req_function(channel->session, channel, channel->callbacks->channel_auth_agent_req_function(channel->session, channel,
channel->callbacks->userdata); channel->callbacks->userdata);
@ -880,7 +880,7 @@ int channel_default_bufferize(ssh_channel channel, void *data, int len,
return -1; return -1;
} }
ssh_log(session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"placing %d bytes into channel buffer (stderr=%d)", len, is_stderr); "placing %d bytes into channel buffer (stderr=%d)", len, is_stderr);
if (is_stderr == 0) { if (is_stderr == 0) {
/* stdout */ /* stdout */
@ -1162,7 +1162,7 @@ int ssh_channel_send_eof(ssh_channel channel){
goto error; goto error;
} }
rc = packet_send(session); rc = packet_send(session);
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sent a EOF on client channel (%d:%d)", "Sent a EOF on client channel (%d:%d)",
channel->local_channel, channel->local_channel,
channel->remote_channel); channel->remote_channel);
@ -1218,7 +1218,7 @@ int ssh_channel_close(ssh_channel channel){
} }
rc = packet_send(session); rc = packet_send(session);
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sent a close on client channel (%d:%d)", "Sent a close on client channel (%d:%d)",
channel->local_channel, channel->local_channel,
channel->remote_channel); channel->remote_channel);
@ -1291,7 +1291,7 @@ int channel_write_common(ssh_channel channel, const void *data,
} }
if (len > INT_MAX) { if (len > INT_MAX) {
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Length (%u) is bigger than INT_MAX", len); "Length (%u) is bigger than INT_MAX", len);
return SSH_ERROR; return SSH_ERROR;
} }
@ -1337,14 +1337,14 @@ int channel_write_common(ssh_channel channel, const void *data,
} }
while (len > 0) { while (len > 0) {
if (channel->remote_window < len) { if (channel->remote_window < len) {
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Remote window is %d bytes. going to write %d bytes", "Remote window is %d bytes. going to write %d bytes",
channel->remote_window, channel->remote_window,
len); len);
/* What happens when the channel window is zero? */ /* What happens when the channel window is zero? */
if(channel->remote_window == 0) { if(channel->remote_window == 0) {
/* nothing can be written */ /* nothing can be written */
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Wait for a growing window message..."); "Wait for a growing window message...");
rc = ssh_handle_packets_termination(session, SSH_TIMEOUT_DEFAULT, rc = ssh_handle_packets_termination(session, SSH_TIMEOUT_DEFAULT,
ssh_channel_waitwindow_termination,channel); ssh_channel_waitwindow_termination,channel);
@ -1382,7 +1382,7 @@ int channel_write_common(ssh_channel channel, const void *data,
return SSH_ERROR; return SSH_ERROR;
} }
ssh_log(session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"channel_write wrote %ld bytes", (long int) effectivelen); "channel_write wrote %ld bytes", (long int) effectivelen);
channel->remote_window -= effectivelen; channel->remote_window -= effectivelen;
@ -1510,17 +1510,17 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_success){
enter_function(); enter_function();
channel=channel_from_msg(session,packet); channel=channel_from_msg(session,packet);
if (channel == NULL) { if (channel == NULL) {
ssh_log(session, SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session)); SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Received SSH_CHANNEL_SUCCESS on channel (%d:%d)", "Received SSH_CHANNEL_SUCCESS on channel (%d:%d)",
channel->local_channel, channel->local_channel,
channel->remote_channel); channel->remote_channel);
if(channel->request_state != SSH_CHANNEL_REQ_STATE_PENDING){ if(channel->request_state != SSH_CHANNEL_REQ_STATE_PENDING){
ssh_log(session, SSH_LOG_RARE, "SSH_CHANNEL_SUCCESS received in incorrect state %d", SSH_LOG(SSH_LOG_RARE, "SSH_CHANNEL_SUCCESS received in incorrect state %d",
channel->request_state); channel->request_state);
} else { } else {
channel->request_state=SSH_CHANNEL_REQ_STATE_ACCEPTED; channel->request_state=SSH_CHANNEL_REQ_STATE_ACCEPTED;
@ -1544,17 +1544,17 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_failure){
enter_function(); enter_function();
channel=channel_from_msg(session,packet); channel=channel_from_msg(session,packet);
if (channel == NULL) { if (channel == NULL) {
ssh_log(session, SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session)); SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Received SSH_CHANNEL_FAILURE on channel (%d:%d)", "Received SSH_CHANNEL_FAILURE on channel (%d:%d)",
channel->local_channel, channel->local_channel,
channel->remote_channel); channel->remote_channel);
if(channel->request_state != SSH_CHANNEL_REQ_STATE_PENDING){ if(channel->request_state != SSH_CHANNEL_REQ_STATE_PENDING){
ssh_log(session, SSH_LOG_RARE, "SSH_CHANNEL_FAILURE received in incorrect state %d", SSH_LOG(SSH_LOG_RARE, "SSH_CHANNEL_FAILURE received in incorrect state %d",
channel->request_state); channel->request_state);
} else { } else {
channel->request_state=SSH_CHANNEL_REQ_STATE_DENIED; channel->request_state=SSH_CHANNEL_REQ_STATE_DENIED;
@ -1615,7 +1615,7 @@ static int channel_request(ssh_channel channel, const char *request,
return rc; return rc;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sent a SSH_MSG_CHANNEL_REQUEST %s", request); "Sent a SSH_MSG_CHANNEL_REQUEST %s", request);
if (reply == 0) { if (reply == 0) {
channel->request_state = SSH_CHANNEL_REQ_STATE_NONE; channel->request_state = SSH_CHANNEL_REQ_STATE_NONE;
@ -1638,7 +1638,7 @@ pending:
rc=SSH_ERROR; rc=SSH_ERROR;
break; break;
case SSH_CHANNEL_REQ_STATE_ACCEPTED: case SSH_CHANNEL_REQ_STATE_ACCEPTED:
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Channel request %s success",request); "Channel request %s success",request);
rc=SSH_OK; rc=SSH_OK;
break; break;
@ -2063,10 +2063,10 @@ SSH_PACKET_CALLBACK(ssh_request_success){
(void)packet; (void)packet;
enter_function(); enter_function();
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Received SSH_REQUEST_SUCCESS"); "Received SSH_REQUEST_SUCCESS");
if(session->global_req_state != SSH_CHANNEL_REQ_STATE_PENDING){ if(session->global_req_state != SSH_CHANNEL_REQ_STATE_PENDING){
ssh_log(session, SSH_LOG_RARE, "SSH_REQUEST_SUCCESS received in incorrect state %d", SSH_LOG(SSH_LOG_RARE, "SSH_REQUEST_SUCCESS received in incorrect state %d",
session->global_req_state); session->global_req_state);
} else { } else {
session->global_req_state=SSH_CHANNEL_REQ_STATE_ACCEPTED; session->global_req_state=SSH_CHANNEL_REQ_STATE_ACCEPTED;
@ -2088,10 +2088,10 @@ SSH_PACKET_CALLBACK(ssh_request_denied){
(void)packet; (void)packet;
enter_function(); enter_function();
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Received SSH_REQUEST_FAILURE"); "Received SSH_REQUEST_FAILURE");
if(session->global_req_state != SSH_CHANNEL_REQ_STATE_PENDING){ if(session->global_req_state != SSH_CHANNEL_REQ_STATE_PENDING){
ssh_log(session, SSH_LOG_RARE, "SSH_REQUEST_DENIED received in incorrect state %d", SSH_LOG(SSH_LOG_RARE, "SSH_REQUEST_DENIED received in incorrect state %d",
session->global_req_state); session->global_req_state);
} else { } else {
session->global_req_state=SSH_CHANNEL_REQ_STATE_DENIED; session->global_req_state=SSH_CHANNEL_REQ_STATE_DENIED;
@ -2166,7 +2166,7 @@ static int global_request(ssh_session session, const char *request,
return rc; return rc;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sent a SSH_MSG_GLOBAL_REQUEST %s", request); "Sent a SSH_MSG_GLOBAL_REQUEST %s", request);
if (reply == 0) { if (reply == 0) {
session->global_req_state=SSH_CHANNEL_REQ_STATE_NONE; session->global_req_state=SSH_CHANNEL_REQ_STATE_NONE;
@ -2181,11 +2181,11 @@ pending:
} }
switch(session->global_req_state){ switch(session->global_req_state){
case SSH_CHANNEL_REQ_STATE_ACCEPTED: case SSH_CHANNEL_REQ_STATE_ACCEPTED:
ssh_log(session, SSH_LOG_PROTOCOL, "Global request %s success",request); SSH_LOG(SSH_LOG_PROTOCOL, "Global request %s success",request);
rc=SSH_OK; rc=SSH_OK;
break; break;
case SSH_CHANNEL_REQ_STATE_DENIED: case SSH_CHANNEL_REQ_STATE_DENIED:
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Global request %s failed", request); "Global request %s failed", request);
ssh_set_error(session, SSH_REQUEST_DENIED, ssh_set_error(session, SSH_REQUEST_DENIED,
"Global request %s failed", request); "Global request %s failed", request);
@ -2716,7 +2716,7 @@ int ssh_channel_read(ssh_channel channel, void *dest, uint32_t count, int is_std
* We may have problem if the window is too small to accept as much data * We may have problem if the window is too small to accept as much data
* as asked * as asked
*/ */
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Read (%d) buffered : %d bytes. Window: %d", "Read (%d) buffered : %d bytes. Window: %d",
count, count,
buffer_get_rest_len(stdbuf), buffer_get_rest_len(stdbuf),

22
src/channels1.c
View File

@ -72,7 +72,7 @@ int channel_open_session1(ssh_channel chan) {
chan->state = SSH_CHANNEL_STATE_OPEN; chan->state = SSH_CHANNEL_STATE_OPEN;
chan->local_maxpacket = 32000; chan->local_maxpacket = 32000;
chan->local_window = 64000; chan->local_window = 64000;
ssh_log(session, SSH_LOG_PACKET, "Opened a SSH1 channel session"); SSH_LOG(SSH_LOG_PACKET, "Opened a SSH1 channel session");
return 0; return 0;
} }
@ -124,7 +124,7 @@ int channel_request_pty_size1(ssh_channel channel, const char *terminal, int col
return -1; return -1;
} }
ssh_log(session, SSH_LOG_FUNCTIONS, "Opening a ssh1 pty"); SSH_LOG(SSH_LOG_FUNCTIONS, "Opening a ssh1 pty");
channel->request_state = SSH_CHANNEL_REQ_STATE_PENDING; channel->request_state = SSH_CHANNEL_REQ_STATE_PENDING;
if (packet_send(session) == SSH_ERROR) { if (packet_send(session) == SSH_ERROR) {
return -1; return -1;
@ -142,13 +142,13 @@ int channel_request_pty_size1(ssh_channel channel, const char *terminal, int col
return SSH_ERROR; return SSH_ERROR;
case SSH_CHANNEL_REQ_STATE_ACCEPTED: case SSH_CHANNEL_REQ_STATE_ACCEPTED:
channel->request_state=SSH_CHANNEL_REQ_STATE_NONE; channel->request_state=SSH_CHANNEL_REQ_STATE_NONE;
ssh_log(session, SSH_LOG_RARE, "PTY: Success"); SSH_LOG(SSH_LOG_RARE, "PTY: Success");
return SSH_OK; return SSH_OK;
case SSH_CHANNEL_REQ_STATE_DENIED: case SSH_CHANNEL_REQ_STATE_DENIED:
channel->request_state=SSH_CHANNEL_REQ_STATE_NONE; channel->request_state=SSH_CHANNEL_REQ_STATE_NONE;
ssh_set_error(session, SSH_REQUEST_DENIED, ssh_set_error(session, SSH_REQUEST_DENIED,
"Server denied PTY allocation"); "Server denied PTY allocation");
ssh_log(session, SSH_LOG_RARE, "PTY: denied\n"); SSH_LOG(SSH_LOG_RARE, "PTY: denied\n");
return SSH_ERROR; return SSH_ERROR;
} }
// Not reached // Not reached
@ -179,7 +179,7 @@ int channel_change_pty_size1(ssh_channel channel, int cols, int rows) {
return SSH_ERROR; return SSH_ERROR;
} }
ssh_log(session, SSH_LOG_PROTOCOL, "Change pty size send"); SSH_LOG(SSH_LOG_PROTOCOL, "Change pty size send");
while(channel->request_state==SSH_CHANNEL_REQ_STATE_PENDING){ while(channel->request_state==SSH_CHANNEL_REQ_STATE_PENDING){
ssh_handle_packets(session, SSH_TIMEOUT_INFINITE); ssh_handle_packets(session, SSH_TIMEOUT_INFINITE);
} }
@ -191,11 +191,11 @@ int channel_change_pty_size1(ssh_channel channel, int cols, int rows) {
return SSH_ERROR; return SSH_ERROR;
case SSH_CHANNEL_REQ_STATE_ACCEPTED: case SSH_CHANNEL_REQ_STATE_ACCEPTED:
channel->request_state=SSH_CHANNEL_REQ_STATE_NONE; channel->request_state=SSH_CHANNEL_REQ_STATE_NONE;
ssh_log(session, SSH_LOG_PROTOCOL, "pty size changed"); SSH_LOG(SSH_LOG_PROTOCOL, "pty size changed");
return SSH_OK; return SSH_OK;
case SSH_CHANNEL_REQ_STATE_DENIED: case SSH_CHANNEL_REQ_STATE_DENIED:
channel->request_state=SSH_CHANNEL_REQ_STATE_NONE; channel->request_state=SSH_CHANNEL_REQ_STATE_NONE;
ssh_log(session, SSH_LOG_RARE, "pty size change denied"); SSH_LOG(SSH_LOG_RARE, "pty size change denied");
ssh_set_error(session, SSH_REQUEST_DENIED, "pty size change denied"); ssh_set_error(session, SSH_REQUEST_DENIED, "pty size change denied");
return SSH_ERROR; return SSH_ERROR;
} }
@ -220,7 +220,7 @@ int channel_request_shell1(ssh_channel channel) {
return -1; return -1;
} }
ssh_log(session, SSH_LOG_RARE, "Launched a shell"); SSH_LOG(SSH_LOG_RARE, "Launched a shell");
return 0; return 0;
} }
@ -250,7 +250,7 @@ int channel_request_exec1(ssh_channel channel, const char *cmd) {
return -1; return -1;
} }
ssh_log(session, SSH_LOG_RARE, "Executing %s ...", cmd); SSH_LOG(SSH_LOG_RARE, "Executing %s ...", cmd);
return 0; return 0;
} }
@ -267,11 +267,11 @@ SSH_PACKET_CALLBACK(ssh_packet_data1){
str = buffer_get_ssh_string(packet); str = buffer_get_ssh_string(packet);
if (str == NULL) { if (str == NULL) {
ssh_log(session, SSH_LOG_FUNCTIONS, "Invalid data packet !\n"); SSH_LOG(SSH_LOG_FUNCTIONS, "Invalid data packet !\n");
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Adding %" PRIdS " bytes data in %d", "Adding %" PRIdS " bytes data in %d",
ssh_string_len(str), is_stderr); ssh_string_len(str), is_stderr);

18
src/client.c
View File

@ -66,7 +66,7 @@ static void socket_callback_connected(int code, int errno_code, void *user){
leave_function(); leave_function();
return; return;
} }
ssh_log(session,SSH_LOG_RARE,"Socket connection callback: %d (%d)",code, errno_code); SSH_LOG(SSH_LOG_RARE,"Socket connection callback: %d (%d)",code, errno_code);
if(code == SSH_SOCKET_CONNECTED_OK) if(code == SSH_SOCKET_CONNECTED_OK)
session->session_state=SSH_SESSION_STATE_SOCKET_CONNECTED; session->session_state=SSH_SESSION_STATE_SOCKET_CONNECTED;
else { else {
@ -115,7 +115,7 @@ static int callback_receive_banner(const void *data, size_t len, void *user) {
ret=i+1; ret=i+1;
session->serverbanner=str; session->serverbanner=str;
session->session_state=SSH_SESSION_STATE_BANNER_RECEIVED; session->session_state=SSH_SESSION_STATE_BANNER_RECEIVED;
ssh_log(session,SSH_LOG_PACKET,"Received banner: %s",str); SSH_LOG(SSH_LOG_PACKET,"Received banner: %s",str);
session->ssh_connection_callback(session); session->ssh_connection_callback(session);
leave_function(); leave_function();
return ret; return ret;
@ -282,7 +282,7 @@ int ssh_service_request(ssh_session session, const char *service) {
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sent SSH_MSG_SERVICE_REQUEST (service %s)", service); "Sent SSH_MSG_SERVICE_REQUEST (service %s)", service);
pending: pending:
rc=ssh_handle_packets_termination(session,SSH_TIMEOUT_USER, rc=ssh_handle_packets_termination(session,SSH_TIMEOUT_USER,
@ -335,7 +335,7 @@ static void ssh_client_connection_callback(ssh_session session){
goto error; goto error;
} }
set_status(session, 0.4f); set_status(session, 0.4f);
ssh_log(session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"SSH server banner: %s", session->serverbanner); "SSH server banner: %s", session->serverbanner);
/* Here we analyze the different protocols the server allows. */ /* Here we analyze the different protocols the server allows. */
@ -391,7 +391,7 @@ static void ssh_client_connection_callback(ssh_session session){
break; break;
case SSH_SESSION_STATE_KEXINIT_RECEIVED: case SSH_SESSION_STATE_KEXINIT_RECEIVED:
set_status(session,0.6f); set_status(session,0.6f);
ssh_list_kex(session, &session->next_crypto->server_kex); ssh_list_kex(&session->next_crypto->server_kex);
if (set_client_kex(session) < 0) { if (set_client_kex(session) < 0) {
goto error; goto error;
} }
@ -498,7 +498,7 @@ int ssh_connect(ssh_session session) {
leave_function(); leave_function();
return SSH_ERROR; return SSH_ERROR;
} }
ssh_log(session,SSH_LOG_RARE,"libssh %s, using threading %s", ssh_copyright(), ssh_threads_get_type()); SSH_LOG(SSH_LOG_RARE,"libssh %s, using threading %s", ssh_copyright(), ssh_threads_get_type());
session->ssh_connection_callback = ssh_client_connection_callback; session->ssh_connection_callback = ssh_client_connection_callback;
session->session_state=SSH_SESSION_STATE_CONNECTING; session->session_state=SSH_SESSION_STATE_CONNECTING;
ssh_socket_set_callbacks(session->socket,&session->socket_callbacks); ssh_socket_set_callbacks(session->socket,&session->socket_callbacks);
@ -528,7 +528,7 @@ int ssh_connect(ssh_session session) {
set_status(session, 0.2f); set_status(session, 0.2f);
session->alive = 1; session->alive = 1;
ssh_log(session,SSH_LOG_PROTOCOL,"Socket connecting, now waiting for the callbacks to work"); SSH_LOG(SSH_LOG_PROTOCOL,"Socket connecting, now waiting for the callbacks to work");
pending: pending:
session->pending_call_state=SSH_PENDING_CALL_CONNECT; session->pending_call_state=SSH_PENDING_CALL_CONNECT;
if(ssh_is_blocking(session)) { if(ssh_is_blocking(session)) {
@ -537,7 +537,7 @@ pending:
if (timeout == 0) { if (timeout == 0) {
timeout = 10 * 1000; timeout = 10 * 1000;
} }
ssh_log(session,SSH_LOG_PACKET,"ssh_connect: Actual timeout : %d", timeout); SSH_LOG(SSH_LOG_PACKET,"ssh_connect: Actual timeout : %d", timeout);
ret = ssh_handle_packets_termination(session, timeout, ssh_connect_termination, session); ret = ssh_handle_packets_termination(session, timeout, ssh_connect_termination, session);
if (ret == SSH_ERROR || !ssh_connect_termination(session)) { if (ret == SSH_ERROR || !ssh_connect_termination(session)) {
ssh_set_error(session, SSH_FATAL, ssh_set_error(session, SSH_FATAL,
@ -554,7 +554,7 @@ pending:
session->session_state = SSH_SESSION_STATE_ERROR; session->session_state = SSH_SESSION_STATE_ERROR;
} }
} }
ssh_log(session,SSH_LOG_PACKET,"ssh_connect: Actual state : %d",session->session_state); SSH_LOG(SSH_LOG_PACKET,"ssh_connect: Actual state : %d",session->session_state);
if(!ssh_is_blocking(session) && !ssh_connect_termination(session)){ if(!ssh_is_blocking(session) && !ssh_connect_termination(session)){
leave_function(); leave_function();
return SSH_AGAIN; return SSH_AGAIN;

4
src/config.c
View File

@ -324,7 +324,7 @@ static int ssh_config_parse_line(ssh_session session, const char *line,
} }
break; break;
case SOC_UNSUPPORTED: case SOC_UNSUPPORTED:
ssh_log(session, SSH_LOG_RARE, "Unsupported option: %s, line: %d\n", SSH_LOG(SSH_LOG_RARE, "Unsupported option: %s, line: %d\n",
keyword, count); keyword, count);
break; break;
default: default:
@ -350,7 +350,7 @@ int ssh_config_parse_file(ssh_session session, const char *filename) {
return 0; return 0;
} }
ssh_log(session, SSH_LOG_RARE, "Reading configuration data from %s", filename); SSH_LOG(SSH_LOG_RARE, "Reading configuration data from %s", filename);
parsing = 1; parsing = 1;
while (fgets(line, sizeof(line), f)) { while (fgets(line, sizeof(line), f)) {

20
src/connect.c
View File

@ -104,7 +104,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(const char *host, int port, struct addrinfo **ai) {
const char *service = NULL; const char *service = NULL;
struct addrinfo hints; struct addrinfo hints;
char s_port[10]; char s_port[10];
@ -127,7 +127,7 @@ static int getai(ssh_session session, const char *host, int port, struct addrinf
if (ssh_is_ipaddr(host)) { if (ssh_is_ipaddr(host)) {
/* this is an IP address */ /* this is an IP address */
ssh_log(session,SSH_LOG_PACKET,"host %s matches an IP address",host); SSH_LOG(SSH_LOG_PACKET,"host %s matches an IP address",host);
hints.ai_flags |= AI_NUMERICHOST; hints.ai_flags |= AI_NUMERICHOST;
} }
@ -157,7 +157,7 @@ static int ssh_connect_ai_timeout(ssh_session session, const char *host,
return -1; return -1;
} }
ssh_log(session, SSH_LOG_RARE, "Trying to connect to host: %s:%d with " SSH_LOG(SSH_LOG_RARE, "Trying to connect to host: %s:%d with "
"timeout %d ms", host, port, timeout_ms); "timeout %d ms", host, port, timeout_ms);
/* The return value is checked later */ /* The return value is checked later */
@ -201,7 +201,7 @@ static int ssh_connect_ai_timeout(ssh_session session, const char *host,
} }
/* s is connected ? */ /* s is connected ? */
ssh_log(session, SSH_LOG_PACKET, "Socket connected with timeout\n"); SSH_LOG(SSH_LOG_PACKET, "Socket connected with timeout\n");
ret = ssh_socket_set_blocking(s); ret = ssh_socket_set_blocking(s);
if (ret < 0) { if (ret < 0) {
ssh_set_error(session, SSH_FATAL, ssh_set_error(session, SSH_FATAL,
@ -232,7 +232,7 @@ socket_t ssh_connect_host(ssh_session session, const char *host,
enter_function(); enter_function();
rc = getai(session,host, port, &ai); rc = getai(host, port, &ai);
if (rc != 0) { if (rc != 0) {
ssh_set_error(session, SSH_FATAL, ssh_set_error(session, SSH_FATAL,
"Failed to resolve hostname %s (%s)", host, gai_strerror(rc)); "Failed to resolve hostname %s (%s)", host, gai_strerror(rc));
@ -253,9 +253,9 @@ socket_t ssh_connect_host(ssh_session session, const char *host,
struct addrinfo *bind_ai; struct addrinfo *bind_ai;
struct addrinfo *bind_itr; struct addrinfo *bind_itr;
ssh_log(session, SSH_LOG_PACKET, "Resolving %s\n", bind_addr); SSH_LOG(SSH_LOG_PACKET, "Resolving %s\n", bind_addr);
rc = getai(session,bind_addr, 0, &bind_ai); rc = getai(bind_addr, 0, &bind_ai);
if (rc != 0) { if (rc != 0) {
ssh_set_error(session, SSH_FATAL, ssh_set_error(session, SSH_FATAL,
"Failed to resolve bind address %s (%s)", "Failed to resolve bind address %s (%s)",
@ -329,7 +329,7 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,
enter_function(); enter_function();
rc = getai(session,host, port, &ai); rc = getai(host, port, &ai);
if (rc != 0) { if (rc != 0) {
ssh_set_error(session, SSH_FATAL, ssh_set_error(session, SSH_FATAL,
"Failed to resolve hostname %s (%s)", host, gai_strerror(rc)); "Failed to resolve hostname %s (%s)", host, gai_strerror(rc));
@ -350,9 +350,9 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,
struct addrinfo *bind_ai; struct addrinfo *bind_ai;
struct addrinfo *bind_itr; struct addrinfo *bind_itr;
ssh_log(session, SSH_LOG_PACKET, "Resolving %s\n", bind_addr); SSH_LOG(SSH_LOG_PACKET, "Resolving %s\n", bind_addr);
rc = getai(session,bind_addr, 0, &bind_ai); rc = getai(bind_addr, 0, &bind_ai);
if (rc != 0) { if (rc != 0) {
ssh_set_error(session, SSH_FATAL, ssh_set_error(session, SSH_FATAL,
"Failed to resolve bind address %s (%s)", "Failed to resolve bind address %s (%s)",

4
src/dh.c
View File

@ -639,7 +639,7 @@ int ssh_client_dh_reply(ssh_session session, ssh_buffer packet){
} }
rc=packet_send(session); rc=packet_send(session);
ssh_log(session, SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent");
return rc; return rc;
error: error:
return SSH_ERROR; return SSH_ERROR;
@ -762,7 +762,7 @@ int make_sessionid(ssh_session session) {
} else if (session->next_crypto->kex_type == SSH_KEX_ECDH_SHA2_NISTP256){ } else if (session->next_crypto->kex_type == SSH_KEX_ECDH_SHA2_NISTP256){
if(session->next_crypto->ecdh_client_pubkey == NULL || if(session->next_crypto->ecdh_client_pubkey == NULL ||
session->next_crypto->ecdh_server_pubkey == NULL){ session->next_crypto->ecdh_server_pubkey == NULL){
ssh_log(session,SSH_LOG_WARNING,"ECDH parameted missing"); SSH_LOG(SSH_LOG_WARNING, "ECDH parameted missing");
goto error; goto error;
} }
rc = buffer_add_ssh_string(buf,session->next_crypto->ecdh_client_pubkey); rc = buffer_add_ssh_string(buf,session->next_crypto->ecdh_client_pubkey);

6
src/ecdh.c
View File

@ -186,7 +186,7 @@ int ssh_client_ecdh_reply(ssh_session session, ssh_buffer packet){
} }
rc=packet_send(session); rc=packet_send(session);
ssh_log(session, SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent");
return rc; return rc;
error: error:
return SSH_ERROR; return SSH_ERROR;
@ -312,7 +312,7 @@ int ssh_server_ecdh_init(ssh_session session, ssh_buffer packet){
return SSH_ERROR; return SSH_ERROR;
} }
ssh_log(session,SSH_LOG_PROTOCOL, "SSH_MSG_KEXDH_REPLY sent"); SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_KEXDH_REPLY sent");
rc = packet_send(session); rc = packet_send(session);
if (rc == SSH_ERROR) { if (rc == SSH_ERROR) {
return SSH_ERROR; return SSH_ERROR;
@ -326,7 +326,7 @@ int ssh_server_ecdh_init(ssh_session session, ssh_buffer packet){
session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
rc = packet_send(session); rc = packet_send(session);
ssh_log(session, SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent");
return rc; return rc;
} }

88
src/gssapi.c
View File

@ -116,18 +116,18 @@ static int ssh_gssapi_send_response(ssh_session session, ssh_string oid){
} }
packet_send(session); packet_send(session);
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sent SSH_MSG_USERAUTH_GSSAPI_RESPONSE"); "Sent SSH_MSG_USERAUTH_GSSAPI_RESPONSE");
return SSH_OK; return SSH_OK;
} }
#endif /* WITH_SERVER */ #endif /* WITH_SERVER */
static void ssh_gssapi_log_error(ssh_session session, int verb, const char *msg, int maj_stat){ static void ssh_gssapi_log_error(int verb, const char *msg, int maj_stat){
gss_buffer_desc buffer; gss_buffer_desc buffer;
OM_uint32 dummy, message_context; OM_uint32 dummy, message_context;
gss_display_status(&dummy,maj_stat,GSS_C_GSS_CODE, GSS_C_NO_OID, &message_context, &buffer); gss_display_status(&dummy,maj_stat,GSS_C_GSS_CODE, GSS_C_NO_OID, &message_context, &buffer);
ssh_log(session, verb, "GSSAPI(%s): %s", msg, (const char *)buffer.value); SSH_LOG(verb, "GSSAPI(%s): %s", msg, (const char *)buffer.value);
} }
#ifdef WITH_SERVER #ifdef WITH_SERVER
@ -178,7 +178,7 @@ int ssh_gssapi_handle_userauth(ssh_session session, const char *user, uint32_t n
unsigned char *oid_s = (unsigned char *) ssh_string_data(oids[i]); unsigned char *oid_s = (unsigned char *) ssh_string_data(oids[i]);
size_t len = ssh_string_len(oids[i]); size_t len = ssh_string_len(oids[i]);
if(len < 2 || oid_s[0] != SSH_OID_TAG || ((size_t)oid_s[1]) != len - 2){ if(len < 2 || oid_s[0] != SSH_OID_TAG || ((size_t)oid_s[1]) != len - 2){
ssh_log(session,SSH_LOG_WARNING,"GSSAPI: received invalid OID"); SSH_LOG(SSH_LOG_WARNING,"GSSAPI: received invalid OID");
continue; continue;
} }
oid.elements = &oid_s[2]; oid.elements = &oid_s[2];
@ -191,7 +191,7 @@ int ssh_gssapi_handle_userauth(ssh_session session, const char *user, uint32_t n
} }
gss_release_oid_set(&min_stat, &supported); gss_release_oid_set(&min_stat, &supported);
if (oid_count == 0){ if (oid_count == 0){
ssh_log(session,SSH_LOG_PROTOCOL,"GSSAPI: no OID match"); SSH_LOG(SSH_LOG_PROTOCOL,"GSSAPI: no OID match");
ssh_auth_reply_default(session, 0); ssh_auth_reply_default(session, 0);
gss_release_oid_set(&min_stat, &both_supported); gss_release_oid_set(&min_stat, &both_supported);
return SSH_OK; return SSH_OK;
@ -205,8 +205,8 @@ int ssh_gssapi_handle_userauth(ssh_session session, const char *user, uint32_t n
maj_stat = gss_import_name(&min_stat, &name_buf, maj_stat = gss_import_name(&min_stat, &name_buf,
(gss_OID) GSS_C_NT_HOSTBASED_SERVICE, &server_name); (gss_OID) GSS_C_NT_HOSTBASED_SERVICE, &server_name);
if (maj_stat != GSS_S_COMPLETE) { if (maj_stat != GSS_S_COMPLETE) {
ssh_log(session, 0, "importing name %d, %d", maj_stat, min_stat); SSH_LOG(0, "importing name %d, %d", maj_stat, min_stat);
ssh_gssapi_log_error(session, 0, "importing name", maj_stat); ssh_gssapi_log_error(0, "importing name", maj_stat);
return -1; return -1;
} }
@ -217,27 +217,27 @@ int ssh_gssapi_handle_userauth(ssh_session session, const char *user, uint32_t n
gss_release_oid_set(&min_stat, &both_supported); gss_release_oid_set(&min_stat, &both_supported);
if (maj_stat != GSS_S_COMPLETE) { if (maj_stat != GSS_S_COMPLETE) {
ssh_log(session, 0, "error acquiring credentials %d, %d", maj_stat, min_stat); SSH_LOG(0, "error acquiring credentials %d, %d", maj_stat, min_stat);
ssh_gssapi_log_error(session, 0, "acquiring creds", maj_stat); ssh_gssapi_log_error(0, "acquiring creds", maj_stat);
ssh_auth_reply_default(session,0); ssh_auth_reply_default(session,0);
return SSH_ERROR; return SSH_ERROR;
} }
ssh_log(session, 0, "acquiring credentials %d, %d", maj_stat, min_stat); SSH_LOG(0, "acquiring credentials %d, %d", maj_stat, min_stat);
/* finding which OID from client we selected */ /* finding which OID from client we selected */
for (i=0 ; i< n_oid ; ++i){ for (i=0 ; i< n_oid ; ++i){
unsigned char *oid_s = (unsigned char *) ssh_string_data(oids[i]); unsigned char *oid_s = (unsigned char *) ssh_string_data(oids[i]);
size_t len = ssh_string_len(oids[i]); size_t len = ssh_string_len(oids[i]);
if(len < 2 || oid_s[0] != SSH_OID_TAG || ((size_t)oid_s[1]) != len - 2){ if(len < 2 || oid_s[0] != SSH_OID_TAG || ((size_t)oid_s[1]) != len - 2){
ssh_log(session,SSH_LOG_WARNING,"GSSAPI: received invalid OID"); SSH_LOG(SSH_LOG_WARNING,"GSSAPI: received invalid OID");
continue; continue;
} }
oid.elements = &oid_s[2]; oid.elements = &oid_s[2];
oid.length = len - 2; oid.length = len - 2;
gss_test_oid_set_member(&min_stat,&oid,selected,&present); gss_test_oid_set_member(&min_stat,&oid,selected,&present);
if(present){ if(present){
ssh_log(session, SSH_LOG_PACKET, "Selected oid %d", i); SSH_LOG(SSH_LOG_PACKET, "Selected oid %d", i);
break; break;
} }
} }
@ -257,12 +257,12 @@ int ssh_gssapi_handle_userauth(ssh_session session, const char *user, uint32_t n
#endif /* WITH_SERVER */ #endif /* WITH_SERVER */
static char * ssh_gssapi_name_to_char(ssh_session session, gss_name_t name){ static char * ssh_gssapi_name_to_char(gss_name_t name){
gss_buffer_desc buffer; gss_buffer_desc buffer;
OM_uint32 maj_stat, min_stat; OM_uint32 maj_stat, min_stat;
char *ptr; char *ptr;
maj_stat = gss_display_name(&min_stat, name, &buffer, NULL); maj_stat = gss_display_name(&min_stat, name, &buffer, NULL);
ssh_gssapi_log_error(session, 0, "converting name", maj_stat); ssh_gssapi_log_error(0, "converting name", maj_stat);
ptr=malloc(buffer.length + 1); ptr=malloc(buffer.length + 1);
memcpy(ptr, buffer.value, buffer.length); memcpy(ptr, buffer.value, buffer.length);
ptr[buffer.length] = '\0'; ptr[buffer.length] = '\0';
@ -285,7 +285,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_token_server){
(void)user; (void)user;
(void)type; (void)type;
ssh_log(session, SSH_LOG_PACKET,"Received SSH_MSG_USERAUTH_GSSAPI_TOKEN"); SSH_LOG(SSH_LOG_PACKET,"Received SSH_MSG_USERAUTH_GSSAPI_TOKEN");
if (!session->gssapi || session->gssapi->state != SSH_GSSAPI_STATE_RCV_TOKEN){ if (!session->gssapi || session->gssapi->state != SSH_GSSAPI_STATE_RCV_TOKEN){
ssh_set_error(session, SSH_FATAL, "Received SSH_MSG_USERAUTH_GSSAPI_TOKEN in invalid state"); ssh_set_error(session, SSH_FATAL, "Received SSH_MSG_USERAUTH_GSSAPI_TOKEN in invalid state");
return SSH_PACKET_USED; return SSH_PACKET_USED;
@ -318,7 +318,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_token_server){
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
hexa = ssh_get_hexa(ssh_string_data(token),ssh_string_len(token)); hexa = ssh_get_hexa(ssh_string_data(token),ssh_string_len(token));
ssh_log(session, SSH_LOG_PACKET, "GSSAPI Token : %s",hexa); SSH_LOG(SSH_LOG_PACKET, "GSSAPI Token : %s",hexa);
SAFE_FREE(hexa); SAFE_FREE(hexa);
input_token.length = ssh_string_len(token); input_token.length = ssh_string_len(token);
input_token.value = ssh_string_data(token); input_token.value = ssh_string_data(token);
@ -326,14 +326,14 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_token_server){
maj_stat = gss_accept_sec_context(&min_stat, &session->gssapi->ctx, session->gssapi->server_creds, maj_stat = gss_accept_sec_context(&min_stat, &session->gssapi->ctx, session->gssapi->server_creds,
&input_token, input_bindings, &client_name, NULL /*mech_oid*/, &output_token, &ret_flags, &input_token, input_bindings, &client_name, NULL /*mech_oid*/, &output_token, &ret_flags,
NULL /*time*/, &session->gssapi->client_creds); NULL /*time*/, &session->gssapi->client_creds);
ssh_gssapi_log_error(session, 0, "accepting token", maj_stat); ssh_gssapi_log_error(0, "accepting token", maj_stat);
ssh_string_free(token); ssh_string_free(token);
if (client_name != GSS_C_NO_NAME){ if (client_name != GSS_C_NO_NAME){
session->gssapi->client_name = client_name; session->gssapi->client_name = client_name;
session->gssapi->canonic_user = ssh_gssapi_name_to_char(session, client_name); session->gssapi->canonic_user = ssh_gssapi_name_to_char(client_name);
} }
if (GSS_ERROR(maj_stat)){ if (GSS_ERROR(maj_stat)){
ssh_gssapi_log_error(session, SSH_LOG_PROTOCOL, "Gssapi error", maj_stat); ssh_gssapi_log_error(SSH_LOG_PROTOCOL, "Gssapi error", maj_stat);
ssh_auth_reply_default(session,0); ssh_auth_reply_default(session,0);
ssh_gssapi_free(session); ssh_gssapi_free(session);
session->gssapi=NULL; session->gssapi=NULL;
@ -342,7 +342,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_token_server){
if (output_token.length != 0){ if (output_token.length != 0){
hexa = ssh_get_hexa(output_token.value, output_token.length); hexa = ssh_get_hexa(output_token.value, output_token.length);
ssh_log(session, SSH_LOG_PACKET, "GSSAPI: sending token %s",hexa); SSH_LOG(SSH_LOG_PACKET, "GSSAPI: sending token %s",hexa);
SAFE_FREE(hexa); SAFE_FREE(hexa);
token = ssh_string_new(output_token.length); token = ssh_string_new(output_token.length);
ssh_string_fill(token, output_token.value, output_token.length); ssh_string_fill(token, output_token.value, output_token.length);
@ -399,7 +399,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_mic){
(void)user; (void)user;
(void)type; (void)type;
ssh_log(session, SSH_LOG_PACKET,"Received SSH_MSG_USERAUTH_GSSAPI_MIC"); SSH_LOG(SSH_LOG_PACKET,"Received SSH_MSG_USERAUTH_GSSAPI_MIC");
mic_token = buffer_get_ssh_string(packet); mic_token = buffer_get_ssh_string(packet);
if (!mic_token){ if (!mic_token){
ssh_set_error(session, SSH_FATAL, "Missing MIC in packet"); ssh_set_error(session, SSH_FATAL, "Missing MIC in packet");
@ -428,8 +428,8 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_mic){
mic_token_buf.value = ssh_string_data(mic_token); mic_token_buf.value = ssh_string_data(mic_token);
maj_stat = gss_verify_mic(&min_stat, session->gssapi->ctx, &mic_buf, &mic_token_buf, NULL); maj_stat = gss_verify_mic(&min_stat, session->gssapi->ctx, &mic_buf, &mic_token_buf, NULL);
ssh_gssapi_log_error(session, 0, "verifying MIC", maj_stat); ssh_gssapi_log_error(0, "verifying MIC", maj_stat);
ssh_gssapi_log_error(session, 0, "verifying MIC (min stat)", min_stat); ssh_gssapi_log_error(0, "verifying MIC (min stat)", min_stat);
if (maj_stat == GSS_S_DEFECTIVE_TOKEN || GSS_ERROR(maj_stat)) if (maj_stat == GSS_S_DEFECTIVE_TOKEN || GSS_ERROR(maj_stat))
goto error; goto error;
} }
@ -571,7 +571,7 @@ static int ssh_gssapi_match(ssh_session session, char *hostname, char *username,
maj_stat = gss_indicate_mechs(&min_stat, &supported); maj_stat = gss_indicate_mechs(&min_stat, &supported);
for (i=0; i < supported->count; ++i){ for (i=0; i < supported->count; ++i){
ptr=ssh_get_hexa(supported->elements[i].elements, supported->elements[i].length); ptr=ssh_get_hexa(supported->elements[i].elements, supported->elements[i].length);
ssh_log(session, SSH_LOG_DEBUG, "GSSAPI oid supported %d : %s\n",i, ptr); SSH_LOG(SSH_LOG_DEBUG, "GSSAPI oid supported %d : %s\n",i, ptr);
SAFE_FREE(ptr); SAFE_FREE(ptr);
} }
@ -580,8 +580,8 @@ static int ssh_gssapi_match(ssh_session session, char *hostname, char *username,
maj_stat = gss_import_name(&min_stat, &user_namebuf, maj_stat = gss_import_name(&min_stat, &user_namebuf,
(gss_OID) GSS_C_NT_USER_NAME, &user_name); (gss_OID) GSS_C_NT_USER_NAME, &user_name);
if (maj_stat != GSS_S_COMPLETE) { if (maj_stat != GSS_S_COMPLETE) {
ssh_log(session, SSH_LOG_DEBUG, "importing name %d, %d", maj_stat, min_stat); SSH_LOG(SSH_LOG_DEBUG, "importing name %d, %d", maj_stat, min_stat);
ssh_gssapi_log_error(session, SSH_LOG_DEBUG, "importing name", maj_stat); ssh_gssapi_log_error(SSH_LOG_DEBUG, "importing name", maj_stat);
return -1; return -1;
} }
@ -591,8 +591,8 @@ static int ssh_gssapi_match(ssh_session session, char *hostname, char *username,
maj_stat = gss_import_name(&min_stat, &host_namebuf, maj_stat = gss_import_name(&min_stat, &host_namebuf,
(gss_OID) GSS_C_NT_HOSTBASED_SERVICE, &host_name); (gss_OID) GSS_C_NT_HOSTBASED_SERVICE, &host_name);
if (maj_stat != GSS_S_COMPLETE) { if (maj_stat != GSS_S_COMPLETE) {
ssh_log(session, 0, "importing name %d, %d", maj_stat, min_stat); SSH_LOG(0, "importing name %d, %d", maj_stat, min_stat);
ssh_gssapi_log_error(session, 0, "importing name", maj_stat); ssh_gssapi_log_error(0, "importing name", maj_stat);
return -1; return -1;
} }
@ -611,7 +611,7 @@ static int ssh_gssapi_match(ssh_session session, char *hostname, char *username,
if (session->gssapi->client.client_deleg_creds != GSS_C_NO_CREDENTIAL){ if (session->gssapi->client.client_deleg_creds != GSS_C_NO_CREDENTIAL){
/* we know the oid is ok since init_sec_context worked */ /* we know the oid is ok since init_sec_context worked */
gss_add_oid_set_member(&min_stat, oid, valid_oids); gss_add_oid_set_member(&min_stat, oid, valid_oids);
ssh_log(session, SSH_LOG_PROTOCOL, "Matched oid %u for server (with forwarding)", i); SSH_LOG(SSH_LOG_PROTOCOL, "Matched oid %u for server (with forwarding)", i);
} else { } else {
gss_create_empty_oid_set(&min_stat, &tmp); gss_create_empty_oid_set(&min_stat, &tmp);
gss_add_oid_set_member(&min_stat, oid, &tmp); gss_add_oid_set_member(&min_stat, oid, &tmp);
@ -622,7 +622,7 @@ static int ssh_gssapi_match(ssh_session session, char *hostname, char *username,
if (!GSS_ERROR(maj_stat)){ if (!GSS_ERROR(maj_stat)){
gss_release_cred(&min_stat, &client_creds); gss_release_cred(&min_stat, &client_creds);
gss_add_oid_set_member(&min_stat,oid,valid_oids); gss_add_oid_set_member(&min_stat,oid,valid_oids);
ssh_log(session, SSH_LOG_PROTOCOL, "Matched oid %u for server", i); SSH_LOG(SSH_LOG_PROTOCOL, "Matched oid %u for server", i);
} }
} }
} }
@ -651,14 +651,14 @@ int ssh_gssapi_auth_mic(ssh_session session){
return SSH_AUTH_ERROR; return SSH_AUTH_ERROR;
ssh_log(session,SSH_LOG_PROTOCOL, "Authenticating with gssapi to host %s with user %s", SSH_LOG(SSH_LOG_PROTOCOL, "Authenticating with gssapi to host %s with user %s",
session->opts.host, session->opts.username); session->opts.host, session->opts.username);
rc = ssh_gssapi_match(session,session->opts.host, session->opts.username, &selected, 0); rc = ssh_gssapi_match(session,session->opts.host, session->opts.username, &selected, 0);
if (rc == SSH_ERROR) if (rc == SSH_ERROR)
return SSH_AUTH_DENIED; return SSH_AUTH_DENIED;
n_oids = selected->count; n_oids = selected->count;
ssh_log(session, SSH_LOG_PROTOCOL, "Sending %d oids", n_oids); SSH_LOG(SSH_LOG_PROTOCOL, "Sending %d oids", n_oids);
oids = calloc(n_oids, sizeof(ssh_string)); oids = calloc(n_oids, sizeof(ssh_string));
@ -709,7 +709,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_response){
(void)type; (void)type;
(void)user; (void)user;
ssh_log(session, SSH_LOG_PACKET, "Received SSH_USERAUTH_GSSAPI_RESPONSE"); SSH_LOG(SSH_LOG_PACKET, "Received SSH_USERAUTH_GSSAPI_RESPONSE");
if (session->auth_state != SSH_AUTH_STATE_GSSAPI_REQUEST_SENT){ if (session->auth_state != SSH_AUTH_STATE_GSSAPI_REQUEST_SENT){
ssh_set_error(session, SSH_FATAL, "Invalid state in ssh_packet_userauth_gssapi_response"); ssh_set_error(session, SSH_FATAL, "Invalid state in ssh_packet_userauth_gssapi_response");
return SSH_PACKET_USED; return SSH_PACKET_USED;
@ -735,7 +735,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_response){
&session->gssapi->client_creds, NULL, NULL); &session->gssapi->client_creds, NULL, NULL);
gss_release_oid_set(&min_stat, &tmp); gss_release_oid_set(&min_stat, &tmp);
if (GSS_ERROR(maj_stat)){ if (GSS_ERROR(maj_stat)){
ssh_gssapi_log_error(session,SSH_LOG_WARNING,"Error acquiring credentials",maj_stat); ssh_gssapi_log_error(SSH_LOG_WARNING,"Error acquiring credentials",maj_stat);
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
} }
@ -745,12 +745,12 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_response){
GSS_C_MUTUAL_FLAG | GSS_C_INTEG_FLAG | (deleg ? GSS_C_DELEG_FLAG : 0), GSS_C_MUTUAL_FLAG | GSS_C_INTEG_FLAG | (deleg ? GSS_C_DELEG_FLAG : 0),
0, NULL, &input_token, NULL, &output_token, NULL, NULL); 0, NULL, &input_token, NULL, &output_token, NULL, NULL);
if(GSS_ERROR(maj_stat)){ if(GSS_ERROR(maj_stat)){
ssh_gssapi_log_error(session, SSH_LOG_WARNING, "Initializing gssapi context", maj_stat); ssh_gssapi_log_error(SSH_LOG_WARNING, "Initializing gssapi context", maj_stat);
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
if (output_token.length != 0){ if (output_token.length != 0){
hexa = ssh_get_hexa(output_token.value, output_token.length); hexa = ssh_get_hexa(output_token.value, output_token.length);
ssh_log(session, SSH_LOG_PACKET, "GSSAPI: sending token %s",hexa); SSH_LOG(SSH_LOG_PACKET, "GSSAPI: sending token %s",hexa);
SAFE_FREE(hexa); SAFE_FREE(hexa);
token = ssh_string_new(output_token.length); token = ssh_string_new(output_token.length);
ssh_string_fill(token, output_token.value, output_token.length); ssh_string_fill(token, output_token.value, output_token.length);
@ -770,7 +770,7 @@ static int ssh_gssapi_send_mic(ssh_session session){
gss_buffer_desc mic_token_buf = GSS_C_EMPTY_BUFFER; gss_buffer_desc mic_token_buf = GSS_C_EMPTY_BUFFER;
ssh_buffer mic_buffer; ssh_buffer mic_buffer;
ssh_log(session, SSH_LOG_PACKET,"Sending SSH_MSG_USERAUTH_GSSAPI_MIC"); SSH_LOG(SSH_LOG_PACKET,"Sending SSH_MSG_USERAUTH_GSSAPI_MIC");
mic_buffer = ssh_gssapi_build_mic(session); mic_buffer = ssh_gssapi_build_mic(session);
if(!mic_buffer){ if(!mic_buffer){
@ -782,7 +782,7 @@ static int ssh_gssapi_send_mic(ssh_session session){
maj_stat = gss_get_mic(&min_stat,session->gssapi->ctx, GSS_C_QOP_DEFAULT, &mic_buf, &mic_token_buf); maj_stat = gss_get_mic(&min_stat,session->gssapi->ctx, GSS_C_QOP_DEFAULT, &mic_buf, &mic_token_buf);
if (GSS_ERROR(maj_stat)){ if (GSS_ERROR(maj_stat)){
ssh_gssapi_log_error(session, 0, "generating MIC", maj_stat); ssh_gssapi_log_error(0, "generating MIC", maj_stat);
return SSH_ERROR; return SSH_ERROR;
} }
@ -803,7 +803,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_token_client){
(void)user; (void)user;
(void)type; (void)type;
ssh_log(session, SSH_LOG_PACKET,"Received SSH_MSG_USERAUTH_GSSAPI_TOKEN"); SSH_LOG(SSH_LOG_PACKET,"Received SSH_MSG_USERAUTH_GSSAPI_TOKEN");
if (!session->gssapi || session->auth_state != SSH_AUTH_STATE_GSSAPI_TOKEN){ if (!session->gssapi || session->auth_state != SSH_AUTH_STATE_GSSAPI_TOKEN){
ssh_set_error(session, SSH_FATAL, "Received SSH_MSG_USERAUTH_GSSAPI_TOKEN in invalid state"); ssh_set_error(session, SSH_FATAL, "Received SSH_MSG_USERAUTH_GSSAPI_TOKEN in invalid state");
return SSH_PACKET_USED; return SSH_PACKET_USED;
@ -815,7 +815,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_token_client){
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
hexa = ssh_get_hexa(ssh_string_data(token),ssh_string_len(token)); hexa = ssh_get_hexa(ssh_string_data(token),ssh_string_len(token));
ssh_log(session, SSH_LOG_PACKET, "GSSAPI Token : %s",hexa); SSH_LOG(SSH_LOG_PACKET, "GSSAPI Token : %s",hexa);
SAFE_FREE(hexa); SAFE_FREE(hexa);
input_token.length = ssh_string_len(token); input_token.length = ssh_string_len(token);
input_token.value = ssh_string_data(token); input_token.value = ssh_string_data(token);
@ -828,14 +828,14 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_token_client){
GSS_C_MUTUAL_FLAG | GSS_C_INTEG_FLAG | (deleg ? GSS_C_DELEG_FLAG : 0), GSS_C_MUTUAL_FLAG | GSS_C_INTEG_FLAG | (deleg ? GSS_C_DELEG_FLAG : 0),
0, NULL, &input_token, NULL, &output_token, NULL, NULL); 0, NULL, &input_token, NULL, &output_token, NULL, NULL);
ssh_gssapi_log_error(session, 0, "accepting token", maj_stat); ssh_gssapi_log_error(0, "accepting token", maj_stat);
ssh_string_free(token); ssh_string_free(token);
if (client_name != GSS_C_NO_NAME){ if (client_name != GSS_C_NO_NAME){
session->gssapi->client_name = client_name; session->gssapi->client_name = client_name;
session->gssapi->canonic_user = ssh_gssapi_name_to_char(session, client_name); session->gssapi->canonic_user = ssh_gssapi_name_to_char(client_name);
} }
if (GSS_ERROR(maj_stat)){ if (GSS_ERROR(maj_stat)){
ssh_gssapi_log_error(session, SSH_LOG_PROTOCOL, "Gssapi error", maj_stat); ssh_gssapi_log_error(SSH_LOG_PROTOCOL, "Gssapi error", maj_stat);
ssh_gssapi_free(session); ssh_gssapi_free(session);
session->gssapi=NULL; session->gssapi=NULL;
return SSH_PACKET_USED; return SSH_PACKET_USED;
@ -843,7 +843,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_token_client){
if (output_token.length != 0){ if (output_token.length != 0){
hexa = ssh_get_hexa(output_token.value, output_token.length); hexa = ssh_get_hexa(output_token.value, output_token.length);
ssh_log(session, SSH_LOG_PACKET, "GSSAPI: sending token %s",hexa); SSH_LOG(SSH_LOG_PACKET, "GSSAPI: sending token %s",hexa);
SAFE_FREE(hexa); SAFE_FREE(hexa);
token = ssh_string_new(output_token.length); token = ssh_string_new(output_token.length);
ssh_string_fill(token, output_token.value, output_token.length); ssh_string_fill(token, output_token.value, output_token.length);

8
src/kex.c
View File

@ -277,7 +277,7 @@ SSH_PACKET_CALLBACK(ssh_packet_kexinit){
(void)user; (void)user;
memset(strings, 0, sizeof(strings)); memset(strings, 0, sizeof(strings));
if (session->session_state == SSH_SESSION_STATE_AUTHENTICATED){ if (session->session_state == SSH_SESSION_STATE_AUTHENTICATED){
ssh_log(session,SSH_LOG_WARNING, "Other side initiating key re-exchange"); SSH_LOG(SSH_LOG_WARNING, "Other side initiating key re-exchange");
} else if(session->session_state != SSH_SESSION_STATE_INITIAL_KEX){ } else if(session->session_state != SSH_SESSION_STATE_INITIAL_KEX){
ssh_set_error(session,SSH_FATAL,"SSH_KEXINIT received in wrong state"); ssh_set_error(session,SSH_FATAL,"SSH_KEXINIT received in wrong state");
goto error; goto error;
@ -351,7 +351,7 @@ error:
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
void ssh_list_kex(ssh_session session, struct ssh_kex_struct *kex) { void ssh_list_kex(struct ssh_kex_struct *kex) {
int i = 0; int i = 0;
#ifdef DEBUG_CRYPTO #ifdef DEBUG_CRYPTO
@ -362,7 +362,7 @@ void ssh_list_kex(ssh_session session, struct ssh_kex_struct *kex) {
if (kex->methods[i] == NULL) { if (kex->methods[i] == NULL) {
continue; continue;
} }
ssh_log(session, SSH_LOG_FUNCTIONS, "%s: %s", SSH_LOG(SSH_LOG_FUNCTIONS, "%s: %s",
ssh_kex_descriptions[i], kex->methods[i]); ssh_kex_descriptions[i], kex->methods[i]);
} }
} }
@ -445,7 +445,7 @@ int ssh_send_kex(ssh_session session, int server_kex) {
goto error; goto error;
} }
ssh_list_kex(session, kex); ssh_list_kex(kex);
for (i = 0; i < KEX_METHODS_SIZE; i++) { for (i = 0; i < KEX_METHODS_SIZE; i++) {
str = ssh_string_from_char(kex->methods[i]); str = ssh_string_from_char(kex->methods[i]);

18
src/kex1.c
View File

@ -247,7 +247,7 @@ static ssh_string encrypt_session_key(ssh_session session, ssh_public_key srvkey
} }
ssh_string_fill(data1, buffer, 32); ssh_string_fill(data1, buffer, 32);
if (ABS(hlen - slen) < 128){ if (ABS(hlen - slen) < 128){
ssh_log(session, SSH_LOG_FUNCTIONS, SSH_LOG(SSH_LOG_FUNCTIONS,
"Difference between server modulus and host modulus is only %d. " "Difference between server modulus and host modulus is only %d. "
"It's illegal and may not work", "It's illegal and may not work",
ABS(hlen - slen)); ABS(hlen - slen));
@ -320,7 +320,7 @@ SSH_PACKET_CALLBACK(ssh_packet_publickey1){
enter_function(); enter_function();
(void)type; (void)type;
(void)user; (void)user;
ssh_log(session, SSH_LOG_PROTOCOL, "Got a SSH_SMSG_PUBLIC_KEY"); SSH_LOG(SSH_LOG_PROTOCOL, "Got a SSH_SMSG_PUBLIC_KEY");
if(session->session_state != SSH_SESSION_STATE_INITIAL_KEX){ if(session->session_state != SSH_SESSION_STATE_INITIAL_KEX){
ssh_set_error(session,SSH_FATAL,"SSH_KEXINIT received in wrong state"); ssh_set_error(session,SSH_FATAL,"SSH_KEXINIT received in wrong state");
goto error; goto error;
@ -354,7 +354,7 @@ SSH_PACKET_CALLBACK(ssh_packet_publickey1){
if ((ko != sizeof(uint32_t)) || !host_mod || !host_exp if ((ko != sizeof(uint32_t)) || !host_mod || !host_exp
|| !server_mod || !server_exp) { || !server_mod || !server_exp) {
ssh_log(session, SSH_LOG_RARE, "Invalid SSH_SMSG_PUBLIC_KEY packet"); SSH_LOG(SSH_LOG_RARE, "Invalid SSH_SMSG_PUBLIC_KEY packet");
ssh_set_error(session, SSH_FATAL, "Invalid SSH_SMSG_PUBLIC_KEY packet"); ssh_set_error(session, SSH_FATAL, "Invalid SSH_SMSG_PUBLIC_KEY packet");
goto error; goto error;
} }
@ -364,7 +364,7 @@ SSH_PACKET_CALLBACK(ssh_packet_publickey1){
protocol_flags = ntohl(protocol_flags); protocol_flags = ntohl(protocol_flags);
supported_ciphers_mask = ntohl(supported_ciphers_mask); supported_ciphers_mask = ntohl(supported_ciphers_mask);
supported_authentications_mask = ntohl(supported_authentications_mask); supported_authentications_mask = ntohl(supported_authentications_mask);
ssh_log(session, SSH_LOG_PROTOCOL, SSH_LOG(SSH_LOG_PROTOCOL,
"Server bits: %d; Host bits: %d; Protocol flags: %.8lx; " "Server bits: %d; Host bits: %d; Protocol flags: %.8lx; "
"Cipher mask: %.8lx; Auth mask: %.8lx", "Cipher mask: %.8lx; Auth mask: %.8lx",
server_bits, server_bits,
@ -409,7 +409,7 @@ SSH_PACKET_CALLBACK(ssh_packet_publickey1){
ssh_set_error(session, SSH_FATAL, "Remote server doesn't accept 3DES"); ssh_set_error(session, SSH_FATAL, "Remote server doesn't accept 3DES");
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PROTOCOL, "Sending SSH_CMSG_SESSION_KEY"); SSH_LOG(SSH_LOG_PROTOCOL, "Sending SSH_CMSG_SESSION_KEY");
if (buffer_add_u8(session->out_buffer, SSH_CMSG_SESSION_KEY) < 0) { if (buffer_add_u8(session->out_buffer, SSH_CMSG_SESSION_KEY) < 0) {
goto error; goto error;
@ -427,7 +427,7 @@ SSH_PACKET_CALLBACK(ssh_packet_publickey1){
} }
bits = ssh_string_len(enc_session) * 8 - 7; bits = ssh_string_len(enc_session) * 8 - 7;
ssh_log(session, SSH_LOG_PROTOCOL, "%d bits, %" PRIdS " bytes encrypted session", SSH_LOG(SSH_LOG_PROTOCOL, "%d bits, %" PRIdS " bytes encrypted session",
bits, ssh_string_len(enc_session)); bits, ssh_string_len(enc_session));
bits = htons(bits); bits = htons(bits);
/* the encrypted mpint */ /* the encrypted mpint */
@ -477,21 +477,21 @@ end:
int ssh_get_kex1(ssh_session session) { int ssh_get_kex1(ssh_session session) {
int ret=SSH_ERROR; int ret=SSH_ERROR;
enter_function(); enter_function();
ssh_log(session, SSH_LOG_PROTOCOL, "Waiting for a SSH_SMSG_PUBLIC_KEY"); SSH_LOG(SSH_LOG_PROTOCOL, "Waiting for a SSH_SMSG_PUBLIC_KEY");
/* Here the callback is called */ /* Here the callback is called */
while(session->session_state==SSH_SESSION_STATE_INITIAL_KEX){ while(session->session_state==SSH_SESSION_STATE_INITIAL_KEX){
ssh_handle_packets(session, SSH_TIMEOUT_USER); ssh_handle_packets(session, SSH_TIMEOUT_USER);
} }
if(session->session_state==SSH_SESSION_STATE_ERROR) if(session->session_state==SSH_SESSION_STATE_ERROR)
goto error; goto error;
ssh_log(session, SSH_LOG_PROTOCOL, "Waiting for a SSH_SMSG_SUCCESS"); SSH_LOG(SSH_LOG_PROTOCOL, "Waiting for a SSH_SMSG_SUCCESS");
/* Waiting for SSH_SMSG_SUCCESS */ /* Waiting for SSH_SMSG_SUCCESS */
while(session->session_state==SSH_SESSION_STATE_KEXINIT_RECEIVED){ while(session->session_state==SSH_SESSION_STATE_KEXINIT_RECEIVED){
ssh_handle_packets(session, SSH_TIMEOUT_USER); ssh_handle_packets(session, SSH_TIMEOUT_USER);
} }
if(session->session_state==SSH_SESSION_STATE_ERROR) if(session->session_state==SSH_SESSION_STATE_ERROR)
goto error; goto error;
ssh_log(session, SSH_LOG_PROTOCOL, "received SSH_SMSG_SUCCESS\n"); SSH_LOG(SSH_LOG_PROTOCOL, "received SSH_SMSG_SUCCESS\n");
ret=SSH_OK; ret=SSH_OK;
error: error:
leave_function(); leave_function();

5
src/known_hosts.c
View File

@ -369,7 +369,7 @@ static int match_hashed_host(ssh_session session, const char *host,
ssh_buffer_free(salt); ssh_buffer_free(salt);
ssh_buffer_free(hash); ssh_buffer_free(hash);
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Matching a hashed host: %s match=%d", host, match); "Matching a hashed host: %s match=%d", host, match);
leave_function(); leave_function();
@ -478,8 +478,7 @@ int ssh_is_server_known(ssh_session session) {
if (match) { if (match) {
/* We got a match. Now check the key type */ /* We got a match. Now check the key type */
if (strcmp(session->current_crypto->server_pubkey_type, type) != 0) { if (strcmp(session->current_crypto->server_pubkey_type, type) != 0) {
ssh_log(session, SSH_LOG(SSH_LOG_PACKET,
SSH_LOG_PACKET,
"ssh_is_server_known: server type [%s] doesn't match the " "ssh_is_server_known: server type [%s] doesn't match the "
"type [%s] in known_hosts file", "type [%s] in known_hosts file",
session->current_crypto->server_pubkey_type, session->current_crypto->server_pubkey_type,

20
src/legacy.c
View File

@ -120,11 +120,11 @@ int ssh_userauth_privatekey_file(ssh_session session,
pubkey = publickey_from_file(session, pubkeyfile, &type); pubkey = publickey_from_file(session, pubkeyfile, &type);
if (pubkey == NULL) { if (pubkey == NULL) {
ssh_log(session, SSH_LOG_RARE, "Public key file %s not found. Trying to generate it.", pubkeyfile); SSH_LOG(SSH_LOG_RARE, "Public key file %s not found. Trying to generate it.", pubkeyfile);
/* auto-detect the key type with type=0 */ /* auto-detect the key type with type=0 */
privkey = privatekey_from_file(session, filename, 0, passphrase); privkey = privatekey_from_file(session, filename, 0, passphrase);
} else { } else {
ssh_log(session, SSH_LOG_RARE, "Public key file %s loaded.", pubkeyfile); SSH_LOG(SSH_LOG_RARE, "Public key file %s loaded.", pubkeyfile);
privkey = privatekey_from_file(session, filename, type, passphrase); privkey = privatekey_from_file(session, filename, type, passphrase);
} }
if (privkey == NULL) { if (privkey == NULL) {
@ -610,8 +610,8 @@ int ssh_publickey_to_file(ssh_session session,
SAFE_FREE(pubkey_64); SAFE_FREE(pubkey_64);
SAFE_FREE(user); SAFE_FREE(user);
ssh_log(session, SSH_LOG_RARE, "Trying to write public key file: %s", file); SSH_LOG(SSH_LOG_RARE, "Trying to write public key file: %s", file);
ssh_log(session, SSH_LOG_PACKET, "public key file content: %s", buffer); SSH_LOG(SSH_LOG_PACKET, "public key file content: %s", buffer);
fp = fopen(file, "w+"); fp = fopen(file, "w+");
if (fp == NULL) { if (fp == NULL) {
@ -652,9 +652,9 @@ int ssh_try_publickey_from_file(ssh_session session,
} }
} }
ssh_log(session, SSH_LOG_PACKET, "Trying to open privatekey %s", keyfile); SSH_LOG(SSH_LOG_PACKET, "Trying to open privatekey %s", keyfile);
if (!ssh_file_readaccess_ok(keyfile)) { if (!ssh_file_readaccess_ok(keyfile)) {
ssh_log(session, SSH_LOG_PACKET, "Failed to open privatekey %s", keyfile); SSH_LOG(SSH_LOG_PACKET, "Failed to open privatekey %s", keyfile);
return -1; return -1;
} }
@ -665,16 +665,16 @@ int ssh_try_publickey_from_file(ssh_session session,
} }
snprintf(pubkey_file, len, "%s.pub", keyfile); snprintf(pubkey_file, len, "%s.pub", keyfile);
ssh_log(session, SSH_LOG_PACKET, "Trying to open publickey %s", SSH_LOG(SSH_LOG_PACKET, "Trying to open publickey %s",
pubkey_file); pubkey_file);
if (!ssh_file_readaccess_ok(pubkey_file)) { if (!ssh_file_readaccess_ok(pubkey_file)) {
ssh_log(session, SSH_LOG_PACKET, "Failed to open publickey %s", SSH_LOG(SSH_LOG_PACKET, "Failed to open publickey %s",
pubkey_file); pubkey_file);
SAFE_FREE(pubkey_file); SAFE_FREE(pubkey_file);
return 1; return 1;
} }
ssh_log(session, SSH_LOG_PACKET, "Success opening public and private key"); SSH_LOG(SSH_LOG_PACKET, "Success opening public and private key");
/* /*
* We are sure both the private and public key file is readable. We return * We are sure both the private and public key file is readable. We return
@ -682,7 +682,7 @@ int ssh_try_publickey_from_file(ssh_session session,
*/ */
pubkey_string = publickey_from_file(session, pubkey_file, &pubkey_type); pubkey_string = publickey_from_file(session, pubkey_file, &pubkey_type);
if (pubkey_string == NULL) { if (pubkey_string == NULL) {
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Wasn't able to open public key file %s: %s", "Wasn't able to open public key file %s: %s",
pubkey_file, pubkey_file,
ssh_get_error(session)); ssh_get_error(session));

44
src/messages.c
View File

@ -79,7 +79,7 @@ static ssh_message ssh_message_new(ssh_session session){
* SSH_MSG_UNIMPLEMENTED * SSH_MSG_UNIMPLEMENTED
*/ */
static int ssh_message_reply_default(ssh_message msg) { static int ssh_message_reply_default(ssh_message msg) {
ssh_log(msg->session, SSH_LOG_FUNCTIONS, "Reporting unknown packet"); SSH_LOG(SSH_LOG_FUNCTIONS, "Reporting unknown packet");
if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_UNIMPLEMENTED) < 0) if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_UNIMPLEMENTED) < 0)
goto error; goto error;
@ -501,7 +501,7 @@ SSH_PACKET_CALLBACK(ssh_packet_service_request){
if (service_c == NULL) { if (service_c == NULL) {
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Received a SERVICE_REQUEST for service %s", service_c); "Received a SERVICE_REQUEST for service %s", service_c);
msg=ssh_message_new(session); msg=ssh_message_new(session);
if(!msg){ if(!msg){
@ -692,7 +692,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Auth request for service %s, method %s for user '%s'", "Auth request for service %s, method %s for user '%s'",
service, method, service, method,
msg->auth_request.username); msg->auth_request.username);
@ -789,7 +789,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
sig_blob = buffer_get_ssh_string(packet); sig_blob = buffer_get_ssh_string(packet);
if(sig_blob == NULL) { if(sig_blob == NULL) {
ssh_log(session, SSH_LOG_PACKET, "Invalid signature packet from peer"); SSH_LOG(SSH_LOG_PACKET, "Invalid signature packet from peer");
msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_ERROR; msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_ERROR;
goto error; goto error;
} }
@ -797,7 +797,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
digest = ssh_msg_userauth_build_digest(session, msg, service); digest = ssh_msg_userauth_build_digest(session, msg, service);
if (digest == NULL) { if (digest == NULL) {
ssh_string_free(sig_blob); ssh_string_free(sig_blob);
ssh_log(session, SSH_LOG_PACKET, "Failed to get digest"); SSH_LOG(SSH_LOG_PACKET, "Failed to get digest");
msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_WRONG; msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_WRONG;
goto error; goto error;
} }
@ -810,14 +810,14 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
ssh_string_free(sig_blob); ssh_string_free(sig_blob);
ssh_buffer_free(digest); ssh_buffer_free(digest);
if (rc < 0) { if (rc < 0) {
ssh_log(session, SSH_LOG(
SSH_LOG_PACKET, SSH_LOG_PACKET,
"Received an invalid signature from peer"); "Received an invalid signature from peer");
msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_WRONG; msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_WRONG;
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, "Valid signature received"); SSH_LOG(SSH_LOG_PACKET, "Valid signature received");
msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_VALID; msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_VALID;
} }
@ -836,7 +836,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
ssh_set_error(session, SSH_FATAL, "USERAUTH_REQUEST: gssapi-with-mic OID count too big (%d)",n_oid); ssh_set_error(session, SSH_FATAL, "USERAUTH_REQUEST: gssapi-with-mic OID count too big (%d)",n_oid);
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, "gssapi: %d OIDs", n_oid); SSH_LOG(SSH_LOG_PACKET, "gssapi: %d OIDs", n_oid);
oids = calloc(n_oid, sizeof(ssh_string)); oids = calloc(n_oid, sizeof(ssh_string));
if (oids == NULL){ if (oids == NULL){
ssh_set_error_oom(session); ssh_set_error_oom(session);
@ -855,7 +855,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
oids[i] = oid; oids[i] = oid;
if(session->common.log_verbosity >= SSH_LOG_PACKET){ if(session->common.log_verbosity >= SSH_LOG_PACKET){
hexa = ssh_get_hexa(ssh_string_data(oid), ssh_string_len(oid)); hexa = ssh_get_hexa(ssh_string_data(oid), ssh_string_len(oid));
ssh_log(session, SSH_LOG_PACKET,"gssapi: OID %d: %s",i, hexa); SSH_LOG(SSH_LOG_PACKET,"gssapi: OID %d: %s",i, hexa);
SAFE_FREE(hexa); SAFE_FREE(hexa);
} }
} }
@ -946,7 +946,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_info_response){
buffer_get_u32(packet, &nanswers); buffer_get_u32(packet, &nanswers);
if (session->kbdint == NULL) { if (session->kbdint == NULL) {
ssh_log(session, SSH_LOG_PROTOCOL, "Warning: Got a keyboard-interactive " SSH_LOG(SSH_LOG_PROTOCOL, "Warning: Got a keyboard-interactive "
"response but it seems we didn't send the request."); "response but it seems we didn't send the request.");
session->kbdint = ssh_kbdint_new(); session->kbdint = ssh_kbdint_new();
@ -958,7 +958,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_info_response){
} }
nanswers = ntohl(nanswers); nanswers = ntohl(nanswers);
ssh_log(session,SSH_LOG_PACKET,"kbdint: %d answers",nanswers); SSH_LOG(SSH_LOG_PACKET,"kbdint: %d answers",nanswers);
if (nanswers > KBDINT_MAX_PROMPT) { if (nanswers > KBDINT_MAX_PROMPT) {
ssh_set_error(session, SSH_FATAL, ssh_set_error(session, SSH_FATAL,
"Too much answers received from client: %u (0x%.4x)", "Too much answers received from client: %u (0x%.4x)",
@ -971,7 +971,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_info_response){
if(nanswers != session->kbdint->nprompts) { if(nanswers != session->kbdint->nprompts) {
/* warn but let the application handle this case */ /* warn but let the application handle this case */
ssh_log(session, SSH_LOG_PROTOCOL, "Warning: Number of prompts and answers" SSH_LOG(SSH_LOG_PROTOCOL, "Warning: Number of prompts and answers"
" mismatch: p=%u a=%u", session->kbdint->nprompts, nanswers); " mismatch: p=%u a=%u", session->kbdint->nprompts, nanswers);
} }
session->kbdint->nanswers = nanswers; session->kbdint->nanswers = nanswers;
@ -1048,7 +1048,7 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open){
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Clients wants to open a %s channel", type_c); "Clients wants to open a %s channel", type_c);
ssh_string_free(type_s); ssh_string_free(type_s);
type_s=NULL; type_s=NULL;
@ -1219,7 +1219,7 @@ int ssh_message_channel_request_open_reply_accept_channel(ssh_message msg, ssh_c
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Accepting a channel request_open for chan %d", chan->remote_channel); "Accepting a channel request_open for chan %d", chan->remote_channel);
if (packet_send(session) == SSH_ERROR) { if (packet_send(session) == SSH_ERROR) {
@ -1285,7 +1285,7 @@ int ssh_message_handle_channel_request(ssh_session session, ssh_channel channel,
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Received a %s channel_request for channel (%d:%d) (want_reply=%hhd)", "Received a %s channel_request for channel (%d:%d) (want_reply=%hhd)",
request, channel->local_channel, channel->remote_channel, want_reply); request, channel->local_channel, channel->remote_channel, want_reply);
@ -1475,7 +1475,7 @@ int ssh_message_channel_request_reply_success(ssh_message msg) {
if (msg->channel_request.want_reply) { if (msg->channel_request.want_reply) {
channel = msg->channel_request.channel->remote_channel; channel = msg->channel_request.channel->remote_channel;
ssh_log(msg->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sending a channel_request success to channel %d", channel); "Sending a channel_request success to channel %d", channel);
if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_CHANNEL_SUCCESS) < 0) { if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_CHANNEL_SUCCESS) < 0) {
@ -1488,7 +1488,7 @@ int ssh_message_channel_request_reply_success(ssh_message msg) {
return packet_send(msg->session); return packet_send(msg->session);
} }
ssh_log(msg->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"The client doesn't want to know the request succeeded"); "The client doesn't want to know the request succeeded");
return SSH_OK; return SSH_OK;
@ -1516,7 +1516,7 @@ SSH_PACKET_CALLBACK(ssh_packet_global_request){
buffer_get_u8(packet, &want_reply); buffer_get_u8(packet, &want_reply);
ssh_log(session,SSH_LOG_PROTOCOL,"Received SSH_MSG_GLOBAL_REQUEST packet"); SSH_LOG(SSH_LOG_PROTOCOL,"Received SSH_MSG_GLOBAL_REQUEST packet");
msg = ssh_message_new(session); msg = ssh_message_new(session);
if (msg == NULL) { if (msg == NULL) {
@ -1540,10 +1540,10 @@ SSH_PACKET_CALLBACK(ssh_packet_global_request){
msg->global_request.bind_address = bind_addr; msg->global_request.bind_address = bind_addr;
msg->global_request.bind_port = bind_port; msg->global_request.bind_port = bind_port;
ssh_log(session, SSH_LOG_PROTOCOL, "Received SSH_MSG_GLOBAL_REQUEST %s %d %s:%d", request, want_reply, bind_addr, bind_port); SSH_LOG(SSH_LOG_PROTOCOL, "Received SSH_MSG_GLOBAL_REQUEST %s %d %s:%d", request, want_reply, bind_addr, bind_port);
if(ssh_callbacks_exists(session->common.callbacks, global_request_function)) { if(ssh_callbacks_exists(session->common.callbacks, global_request_function)) {
ssh_log(session, SSH_LOG_PROTOCOL, "Calling callback for SSH_MSG_GLOBAL_REQUEST %s %d %s:%d", request, want_reply, bind_addr, bind_port); SSH_LOG(SSH_LOG_PROTOCOL, "Calling callback for SSH_MSG_GLOBAL_REQUEST %s %d %s:%d", request, want_reply, bind_addr, bind_port);
session->common.callbacks->global_request_function(session, msg, session->common.callbacks->userdata); session->common.callbacks->global_request_function(session, msg, session->common.callbacks->userdata);
} else { } else {
ssh_message_reply_default(msg); ssh_message_reply_default(msg);
@ -1562,7 +1562,7 @@ SSH_PACKET_CALLBACK(ssh_packet_global_request){
msg->global_request.bind_address = bind_addr; msg->global_request.bind_address = bind_addr;
msg->global_request.bind_port = bind_port; msg->global_request.bind_port = bind_port;
ssh_log(session, SSH_LOG_PROTOCOL, "Received SSH_MSG_GLOBAL_REQUEST %s %d %s:%d", request, want_reply, bind_addr, bind_port); SSH_LOG(SSH_LOG_PROTOCOL, "Received SSH_MSG_GLOBAL_REQUEST %s %d %s:%d", request, want_reply, bind_addr, bind_port);
if(ssh_callbacks_exists(session->common.callbacks, global_request_function)) { if(ssh_callbacks_exists(session->common.callbacks, global_request_function)) {
session->common.callbacks->global_request_function(session, msg, session->common.callbacks->userdata); session->common.callbacks->global_request_function(session, msg, session->common.callbacks->userdata);
@ -1570,7 +1570,7 @@ SSH_PACKET_CALLBACK(ssh_packet_global_request){
ssh_message_reply_default(msg); ssh_message_reply_default(msg);
} }
} else { } else {
ssh_log(session, SSH_LOG_PROTOCOL, "UNKNOWN SSH_MSG_GLOBAL_REQUEST %s %d", request, want_reply); SSH_LOG(SSH_LOG_PROTOCOL, "UNKNOWN SSH_MSG_GLOBAL_REQUEST %s %d", request, want_reply);
rc = SSH_PACKET_NOT_USED; rc = SSH_PACKET_NOT_USED;
} }

4
src/misc.c
View File

@ -839,7 +839,7 @@ int ssh_analyze_banner(ssh_session session, int server, int *ssh1, int *ssh2) {
return -1; return -1;
} }
ssh_log(session, SSH_LOG_RARE, "Analyzing banner: %s", banner); SSH_LOG(SSH_LOG_RARE, "Analyzing banner: %s", banner);
switch(banner[4]) { switch(banner[4]) {
case '1': case '1':
@ -874,7 +874,7 @@ int ssh_analyze_banner(ssh_session session, int server, int *ssh1, int *ssh2) {
major = strtol(openssh + 8, (char **) NULL, 10); major = strtol(openssh + 8, (char **) NULL, 10);
minor = strtol(openssh + 10, (char **) NULL, 10); minor = strtol(openssh + 10, (char **) NULL, 10);
session->openssh = SSH_VERSION_INT(major, minor, 0); session->openssh = SSH_VERSION_INT(major, minor, 0);
ssh_log(session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"We are talking to an OpenSSH client version: %d.%d (%x)", "We are talking to an OpenSSH client version: %d.%d (%x)",
major, minor, session->openssh); major, minor, session->openssh);
} }

19
src/packet.c
View File

@ -215,7 +215,7 @@ int ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user)
if (to_be_read != 0) { if (to_be_read != 0) {
if(receivedlen - processed < (unsigned int)to_be_read){ if(receivedlen - processed < (unsigned int)to_be_read){
/* give up, not enough data in buffer */ /* give up, not enough data in buffer */
ssh_log(session,SSH_LOG_PACKET,"packet: partial packet (read len) [len=%d]",len); SSH_LOG(SSH_LOG_PACKET,"packet: partial packet (read len) [len=%d]",len);
return processed; return processed;
} }
@ -282,7 +282,7 @@ int ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user)
/* We don't want to rewrite a new packet while still executing the packet callbacks */ /* We don't want to rewrite a new packet while still executing the packet callbacks */
session->packet_state = PACKET_STATE_PROCESSING; session->packet_state = PACKET_STATE_PROCESSING;
ssh_packet_parse_type(session); ssh_packet_parse_type(session);
ssh_log(session,SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"packet: read type %hhd [len=%d,padding=%hhd,comp=%d,payload=%d]", "packet: read type %hhd [len=%d,padding=%hhd,comp=%d,payload=%d]",
session->in_packet.type, len, padding, compsize, payloadsize); session->in_packet.type, len, padding, compsize, payloadsize);
/* execute callbacks */ /* execute callbacks */
@ -290,7 +290,7 @@ int ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user)
session->packet_state = PACKET_STATE_INIT; session->packet_state = PACKET_STATE_INIT;
if(processed < receivedlen){ if(processed < receivedlen){
/* Handle a potential packet left in socket buffer */ /* Handle a potential packet left in socket buffer */
ssh_log(session,SSH_LOG_PACKET,"Processing %" PRIdS " bytes left in socket buffer", SSH_LOG(SSH_LOG_PACKET,"Processing %" PRIdS " bytes left in socket buffer",
receivedlen-processed); receivedlen-processed);
rc = ssh_packet_socket_callback(((unsigned char *)data) + processed, rc = ssh_packet_socket_callback(((unsigned char *)data) + processed,
receivedlen - processed,user); receivedlen - processed,user);
@ -299,7 +299,7 @@ int ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user)
leave_function(); leave_function();
return processed; return processed;
case PACKET_STATE_PROCESSING: case PACKET_STATE_PROCESSING:
ssh_log(session, SSH_LOG_RARE, "Nested packet processing. Delaying."); SSH_LOG(SSH_LOG_RARE, "Nested packet processing. Delaying.");
return 0; return 0;
} }
@ -360,9 +360,9 @@ void ssh_packet_process(ssh_session session, uint8_t type){
int r=SSH_PACKET_NOT_USED; int r=SSH_PACKET_NOT_USED;
ssh_packet_callbacks cb; ssh_packet_callbacks cb;
enter_function(); enter_function();
ssh_log(session,SSH_LOG_PACKET, "Dispatching handler for packet type %d",type); SSH_LOG(SSH_LOG_PACKET, "Dispatching handler for packet type %d",type);
if(session->packet_callbacks == NULL){ if(session->packet_callbacks == NULL){
ssh_log(session,SSH_LOG_RARE,"Packet callback is not initialized !"); SSH_LOG(SSH_LOG_RARE,"Packet callback is not initialized !");
goto error; goto error;
} }
i=ssh_list_get_iterator(session->packet_callbacks); i=ssh_list_get_iterator(session->packet_callbacks);
@ -382,7 +382,7 @@ void ssh_packet_process(ssh_session session, uint8_t type){
break; break;
} }
if(r==SSH_PACKET_NOT_USED){ if(r==SSH_PACKET_NOT_USED){
ssh_log(session,SSH_LOG_RARE,"Couldn't do anything with packet type %d",type); SSH_LOG(SSH_LOG_RARE,"Couldn't do anything with packet type %d",type);
ssh_packet_send_unimplemented(session, session->recv_seq-1); ssh_packet_send_unimplemented(session, session->recv_seq-1);
} }
error: error:
@ -416,11 +416,12 @@ int ssh_packet_send_unimplemented(ssh_session session, uint32_t seqnum){
*/ */
SSH_PACKET_CALLBACK(ssh_packet_unimplemented){ SSH_PACKET_CALLBACK(ssh_packet_unimplemented){
uint32_t seq; uint32_t seq;
(void)session; /* unused */
(void)type; (void)type;
(void)user; (void)user;
buffer_get_u32(packet,&seq); buffer_get_u32(packet,&seq);
seq=ntohl(seq); seq=ntohl(seq);
ssh_log(session,SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"Received SSH_MSG_UNIMPLEMENTED (sequence number %d)",seq); "Received SSH_MSG_UNIMPLEMENTED (sequence number %d)",seq);
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
@ -529,7 +530,7 @@ static int packet_send2(ssh_session session) {
rc = ssh_packet_write(session); rc = ssh_packet_write(session);
session->send_seq++; session->send_seq++;
ssh_log(session,SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"packet: wrote [len=%d,padding=%hhd,comp=%d,payload=%d]", "packet: wrote [len=%d,padding=%hhd,comp=%d,payload=%d]",
ntohl(finallen), padding, compsize, payloadsize); ntohl(finallen), padding, compsize, payloadsize);
if (buffer_reinit(session->out_buffer) < 0) { if (buffer_reinit(session->out_buffer) < 0) {

20
src/packet1.c
View File

@ -140,7 +140,7 @@ int ssh_packet_socket_callback1(const void *data, size_t receivedlen, void *user
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, "Reading a %d bytes packet", len); SSH_LOG(SSH_LOG_PACKET, "Reading a %d bytes packet", len);
session->in_packet.len = len; session->in_packet.len = len;
session->packet_state = PACKET_STATE_SIZEREAD; session->packet_state = PACKET_STATE_SIZEREAD;
@ -182,10 +182,10 @@ int ssh_packet_socket_callback1(const void *data, size_t receivedlen, void *user
ssh_print_hexa("read packet decrypted:", ssh_buffer_get_begin(session->in_buffer), ssh_print_hexa("read packet decrypted:", ssh_buffer_get_begin(session->in_buffer),
ssh_buffer_get_len(session->in_buffer)); ssh_buffer_get_len(session->in_buffer));
#endif #endif
ssh_log(session, SSH_LOG_PACKET, "%d bytes padding", padding); SSH_LOG(SSH_LOG_PACKET, "%d bytes padding", padding);
if(((len + padding) != buffer_get_rest_len(session->in_buffer)) || if(((len + padding) != buffer_get_rest_len(session->in_buffer)) ||
((len + padding) < sizeof(uint32_t))) { ((len + padding) < sizeof(uint32_t))) {
ssh_log(session, SSH_LOG_RARE, "no crc32 in packet"); SSH_LOG(SSH_LOG_RARE, "no crc32 in packet");
ssh_set_error(session, SSH_FATAL, "no crc32 in packet"); ssh_set_error(session, SSH_FATAL, "no crc32 in packet");
goto error; goto error;
} }
@ -201,7 +201,7 @@ int ssh_packet_socket_callback1(const void *data, size_t receivedlen, void *user
ssh_print_hexa("crc32 on",buffer_get_rest(session->in_buffer), ssh_print_hexa("crc32 on",buffer_get_rest(session->in_buffer),
len + padding - sizeof(uint32_t)); len + padding - sizeof(uint32_t));
#endif #endif
ssh_log(session, SSH_LOG_RARE, "Invalid crc32"); SSH_LOG(SSH_LOG_RARE, "Invalid crc32");
ssh_set_error(session, SSH_FATAL, ssh_set_error(session, SSH_FATAL,
"Invalid crc32: expected %.8x, got %.8x", "Invalid crc32: expected %.8x, got %.8x",
crc, crc,
@ -211,7 +211,7 @@ int ssh_packet_socket_callback1(const void *data, size_t receivedlen, void *user
} }
/* pass the padding */ /* pass the padding */
buffer_pass_bytes(session->in_buffer, padding); buffer_pass_bytes(session->in_buffer, padding);
ssh_log(session, SSH_LOG_PACKET, "The packet is valid"); SSH_LOG(SSH_LOG_PACKET, "The packet is valid");
/* TODO FIXME /* TODO FIXME
#ifdef WITH_ZLIB #ifdef WITH_ZLIB
@ -230,7 +230,7 @@ int ssh_packet_socket_callback1(const void *data, size_t receivedlen, void *user
if(processed < receivedlen){ if(processed < receivedlen){
int rc; int rc;
/* Handle a potential packet left in socket buffer */ /* Handle a potential packet left in socket buffer */
ssh_log(session,SSH_LOG_PACKET,"Processing %" PRIdS " bytes left in socket buffer", SSH_LOG(SSH_LOG_PACKET,"Processing %" PRIdS " bytes left in socket buffer",
receivedlen-processed); receivedlen-processed);
rc = ssh_packet_socket_callback1((char *)data + processed, rc = ssh_packet_socket_callback1((char *)data + processed,
receivedlen - processed,user); receivedlen - processed,user);
@ -239,7 +239,7 @@ int ssh_packet_socket_callback1(const void *data, size_t receivedlen, void *user
leave_function(); leave_function();
return processed; return processed;
case PACKET_STATE_PROCESSING: case PACKET_STATE_PROCESSING:
ssh_log(session, SSH_LOG_RARE, "Nested packet processing. Delaying."); SSH_LOG(SSH_LOG_RARE, "Nested packet processing. Delaying.");
return 0; return 0;
} }
@ -261,7 +261,7 @@ int packet_send1(ssh_session session) {
uint8_t padding; uint8_t padding;
enter_function(); enter_function();
ssh_log(session,SSH_LOG_PACKET,"Sending a %d bytes long packet",currentlen); SSH_LOG(SSH_LOG_PACKET,"Sending a %d bytes long packet",currentlen);
/* TODO FIXME /* TODO FIXME
#ifdef WITH_ZLIB #ifdef WITH_ZLIB
@ -281,7 +281,7 @@ int packet_send1(ssh_session session) {
} }
finallen = htonl(currentlen); finallen = htonl(currentlen);
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"%d bytes after comp + %d padding bytes = %d bytes packet", "%d bytes after comp + %d padding bytes = %d bytes packet",
currentlen, padding, ntohl(finallen)); currentlen, padding, ntohl(finallen));
@ -331,7 +331,7 @@ SSH_PACKET_CALLBACK(ssh_packet_disconnect1){
(void)packet; (void)packet;
(void)user; (void)user;
(void)type; (void)type;
ssh_log(session, SSH_LOG_PACKET, "Received SSH_MSG_DISCONNECT"); SSH_LOG(SSH_LOG_PACKET, "Received SSH_MSG_DISCONNECT");
ssh_set_error(session, SSH_FATAL, "Received SSH_MSG_DISCONNECT"); ssh_set_error(session, SSH_FATAL, "Received SSH_MSG_DISCONNECT");
ssh_socket_close(session->socket); ssh_socket_close(session->socket);
session->alive = 0; session->alive = 0;

13
src/packet_cb.c
View File

@ -53,7 +53,7 @@ SSH_PACKET_CALLBACK(ssh_packet_disconnect_callback){
error = ssh_string_to_char(error_s); error = ssh_string_to_char(error_s);
ssh_string_free(error_s); ssh_string_free(error_s);
} }
ssh_log(session, SSH_LOG_PACKET, "Received SSH_MSG_DISCONNECT %d:%s",code, SSH_LOG(SSH_LOG_PACKET, "Received SSH_MSG_DISCONNECT %d:%s",code,
error != NULL ? error : "no error"); error != NULL ? error : "no error");
ssh_set_error(session, SSH_FATAL, ssh_set_error(session, SSH_FATAL,
"Received SSH_MSG_DISCONNECT: %d:%s",code, "Received SSH_MSG_DISCONNECT: %d:%s",code,
@ -73,10 +73,11 @@ SSH_PACKET_CALLBACK(ssh_packet_disconnect_callback){
* @brief Handle a SSH_IGNORE and SSH_DEBUG packet. * @brief Handle a SSH_IGNORE and SSH_DEBUG packet.
*/ */
SSH_PACKET_CALLBACK(ssh_packet_ignore_callback){ SSH_PACKET_CALLBACK(ssh_packet_ignore_callback){
(void)session; /* unused */
(void)user; (void)user;
(void)type; (void)type;
(void)packet; (void)packet;
ssh_log(session,SSH_LOG_PROTOCOL,"Received %s packet",type==SSH2_MSG_IGNORE ? "SSH_MSG_IGNORE" : "SSH_MSG_DEBUG"); SSH_LOG(SSH_LOG_PROTOCOL,"Received %s packet",type==SSH2_MSG_IGNORE ? "SSH_MSG_IGNORE" : "SSH_MSG_DEBUG");
/* TODO: handle a graceful disconnect */ /* TODO: handle a graceful disconnect */
return SSH_PACKET_USED; return SSH_PACKET_USED;
} }
@ -85,7 +86,7 @@ SSH_PACKET_CALLBACK(ssh_packet_dh_reply){
int rc; int rc;
(void)type; (void)type;
(void)user; (void)user;
ssh_log(session,SSH_LOG_PROTOCOL,"Received SSH_KEXDH_REPLY"); SSH_LOG(SSH_LOG_PROTOCOL,"Received SSH_KEXDH_REPLY");
if(session->session_state!= SSH_SESSION_STATE_DH && if(session->session_state!= SSH_SESSION_STATE_DH &&
session->dh_handshake_state != DH_STATE_INIT_SENT){ session->dh_handshake_state != DH_STATE_INIT_SENT){
ssh_set_error(session,SSH_FATAL,"ssh_packet_dh_reply called in wrong state : %d:%d", ssh_set_error(session,SSH_FATAL,"ssh_packet_dh_reply called in wrong state : %d:%d",
@ -121,7 +122,7 @@ SSH_PACKET_CALLBACK(ssh_packet_newkeys){
(void)packet; (void)packet;
(void)user; (void)user;
(void)type; (void)type;
ssh_log(session, SSH_LOG_PROTOCOL, "Received SSH_MSG_NEWKEYS"); SSH_LOG(SSH_LOG_PROTOCOL, "Received SSH_MSG_NEWKEYS");
if(session->session_state!= SSH_SESSION_STATE_DH && if(session->session_state!= SSH_SESSION_STATE_DH &&
session->dh_handshake_state != DH_STATE_NEWKEYS_SENT){ session->dh_handshake_state != DH_STATE_NEWKEYS_SENT){
ssh_set_error(session,SSH_FATAL,"ssh_packet_newkeys called in wrong state : %d:%d", ssh_set_error(session,SSH_FATAL,"ssh_packet_newkeys called in wrong state : %d:%d",
@ -191,7 +192,7 @@ SSH_PACKET_CALLBACK(ssh_packet_newkeys){
if (rc == SSH_ERROR) { if (rc == SSH_ERROR) {
goto error; goto error;
} }
ssh_log(session,SSH_LOG_PROTOCOL,"Signature verified and valid"); SSH_LOG(SSH_LOG_PROTOCOL,"Signature verified and valid");
/* /*
* Once we got SSH2_MSG_NEWKEYS we can switch next_crypto and * Once we got SSH2_MSG_NEWKEYS we can switch next_crypto and
@ -237,7 +238,7 @@ SSH_PACKET_CALLBACK(ssh_packet_service_accept){
(void)user; (void)user;
enter_function(); enter_function();
session->auth_service_state=SSH_AUTH_SERVICE_ACCEPTED; session->auth_service_state=SSH_AUTH_SERVICE_ACCEPTED;
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Received SSH_MSG_SERVICE_ACCEPT"); "Received SSH_MSG_SERVICE_ACCEPT");
leave_function(); leave_function();
return SSH_PACKET_USED; return SSH_PACKET_USED;

3
src/pki.c
View File

@ -1220,8 +1220,7 @@ int ssh_pki_signature_verify_blob(ssh_session session,
return SSH_ERROR; return SSH_ERROR;
} }
ssh_log(session, SSH_LOG(SSH_LOG_FUNCTIONS,
SSH_LOG_FUNCTIONS,
"Going to verify a %s type signature", "Going to verify a %s type signature",
key->type_c); key->type_c);

8
src/scp.c
View File

@ -93,7 +93,7 @@ int ssh_scp_init(ssh_scp scp){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_init called under invalid state"); ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_init called under invalid state");
return SSH_ERROR; return SSH_ERROR;
} }
ssh_log(scp->session,SSH_LOG_PROTOCOL,"Initializing scp session %s %son location '%s'", SSH_LOG(SSH_LOG_PROTOCOL,"Initializing scp session %s %son location '%s'",
scp->mode==SSH_SCP_WRITE?"write":"read", scp->mode==SSH_SCP_WRITE?"write":"read",
scp->recursive?"recursive ":"", scp->recursive?"recursive ":"",
scp->location); scp->location);
@ -300,7 +300,7 @@ int ssh_scp_push_file64(ssh_scp scp, const char *filename, uint64_t size, int mo
} }
file=ssh_basename(filename); file=ssh_basename(filename);
perms=ssh_scp_string_mode(mode); perms=ssh_scp_string_mode(mode);
ssh_log(scp->session,SSH_LOG_PROTOCOL,"SCP pushing file %s, size %" PRIu64 " with permissions '%s'",file,size,perms); SSH_LOG(SSH_LOG_PROTOCOL,"SCP pushing file %s, size %" PRIu64 " with permissions '%s'",file,size,perms);
snprintf(buffer, sizeof(buffer), "C%s %" PRIu64 " %s\n", perms, size, file); snprintf(buffer, sizeof(buffer), "C%s %" PRIu64 " %s\n", perms, size, file);
SAFE_FREE(file); SAFE_FREE(file);
SAFE_FREE(perms); SAFE_FREE(perms);
@ -379,7 +379,7 @@ int ssh_scp_response(ssh_scp scp, char **response){
/* Warning */ /* Warning */
if(code == 1){ if(code == 1){
ssh_set_error(scp->session,SSH_REQUEST_DENIED, "SCP: Warning: status code 1 received: %s", msg); ssh_set_error(scp->session,SSH_REQUEST_DENIED, "SCP: Warning: status code 1 received: %s", msg);
ssh_log(scp->session,SSH_LOG_RARE,"SCP: Warning: status code 1 received: %s", msg); SSH_LOG(SSH_LOG_RARE,"SCP: Warning: status code 1 received: %s", msg);
if(response) if(response)
*response=strdup(msg); *response=strdup(msg);
return 1; return 1;
@ -540,7 +540,7 @@ int ssh_scp_pull_request(ssh_scp scp){
p=strchr(buffer,'\n'); p=strchr(buffer,'\n');
if(p!=NULL) if(p!=NULL)
*p='\0'; *p='\0';
ssh_log(scp->session,SSH_LOG_PROTOCOL,"Received SCP request: '%s'",buffer); SSH_LOG(SSH_LOG_PROTOCOL,"Received SCP request: '%s'",buffer);
switch(buffer[0]){ switch(buffer[0]){
case 'C': case 'C':
/* File */ /* File */

40
src/server.c
View File

@ -168,9 +168,9 @@ SSH_PACKET_CALLBACK(ssh_packet_kexdh_init){
(void)type; (void)type;
(void)user; (void)user;
enter_function(); enter_function();
ssh_log(session,SSH_LOG_PACKET,"Received SSH_MSG_KEXDH_INIT"); SSH_LOG(SSH_LOG_PACKET,"Received SSH_MSG_KEXDH_INIT");
if(session->dh_handshake_state != DH_STATE_INIT){ if(session->dh_handshake_state != DH_STATE_INIT){
ssh_log(session,SSH_LOG_RARE,"Invalid state for SSH_MSG_KEXDH_INIT"); SSH_LOG(SSH_LOG_RARE,"Invalid state for SSH_MSG_KEXDH_INIT");
goto error; goto error;
} }
switch(session->next_crypto->kex_type){ switch(session->next_crypto->kex_type){
@ -303,7 +303,7 @@ static int dh_handshake_server(ssh_session session) {
if (packet_send(session) == SSH_ERROR) { if (packet_send(session) == SSH_ERROR) {
return -1; return -1;
} }
ssh_log(session, SSH_LOG_PACKET, "SSH_MSG_NEWKEYS sent"); SSH_LOG(SSH_LOG_PACKET, "SSH_MSG_NEWKEYS sent");
session->dh_handshake_state=DH_STATE_NEWKEYS_SENT; session->dh_handshake_state=DH_STATE_NEWKEYS_SENT;
return 0; return 0;
@ -328,7 +328,7 @@ static void ssh_server_connection_callback(ssh_session session){
goto error; goto error;
} }
set_status(session, 0.4f); set_status(session, 0.4f);
ssh_log(session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"SSH client banner: %s", session->clientbanner); "SSH client banner: %s", session->clientbanner);
/* Here we analyze the different protocols the server allows. */ /* Here we analyze the different protocols the server allows. */
@ -391,7 +391,7 @@ static void ssh_server_connection_callback(ssh_session session){
if(ssh_send_kex(session, 1) < 0) if(ssh_send_kex(session, 1) < 0)
goto error; goto error;
} }
ssh_list_kex(session, &session->next_crypto->client_kex); // log client kex ssh_list_kex(&session->next_crypto->client_kex); // log client kex
if (ssh_kex_select_methods(session) < 0) { if (ssh_kex_select_methods(session) < 0) {
goto error; goto error;
} }
@ -493,7 +493,7 @@ static int callback_receive_banner(const void *data, size_t len, void *user) {
ret = i + 1; ret = i + 1;
session->clientbanner = str; session->clientbanner = str;
session->session_state = SSH_SESSION_STATE_BANNER_RECEIVED; session->session_state = SSH_SESSION_STATE_BANNER_RECEIVED;
ssh_log(session, SSH_LOG_PACKET, "Received banner: %s", str); SSH_LOG(SSH_LOG_PACKET, "Received banner: %s", str);
session->ssh_connection_callback(session); session->ssh_connection_callback(session);
leave_function(); leave_function();
@ -562,7 +562,7 @@ int ssh_handle_key_exchange(ssh_session session) {
pending: pending:
rc = ssh_handle_packets_termination(session, SSH_TIMEOUT_USER, rc = ssh_handle_packets_termination(session, SSH_TIMEOUT_USER,
ssh_server_kex_termination,session); ssh_server_kex_termination,session);
ssh_log(session,SSH_LOG_PACKET, "ssh_handle_key_exchange: current state : %d", SSH_LOG(SSH_LOG_PACKET, "ssh_handle_key_exchange: current state : %d",
session->session_state); session->session_state);
if (rc != SSH_OK) if (rc != SSH_OK)
return rc; return rc;
@ -621,7 +621,7 @@ int ssh_auth_reply_default(ssh_session session,int partial) {
/* Strip the comma. */ /* Strip the comma. */
methods_c[strlen(methods_c) - 1] = '\0'; // strip the comma. We are sure there is at methods_c[strlen(methods_c) - 1] = '\0'; // strip the comma. We are sure there is at
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sending a auth failure. methods that can continue: %s", methods_c); "Sending a auth failure. methods that can continue: %s", methods_c);
methods = ssh_string_from_char(methods_c); methods = ssh_string_from_char(methods_c);
@ -652,7 +652,7 @@ error:
} }
static int ssh_message_channel_request_open_reply_default(ssh_message msg) { static int ssh_message_channel_request_open_reply_default(ssh_message msg) {
ssh_log(msg->session, SSH_LOG_FUNCTIONS, "Refusing a channel"); SSH_LOG(SSH_LOG_FUNCTIONS, "Refusing a channel");
if (buffer_add_u8(msg->session->out_buffer if (buffer_add_u8(msg->session->out_buffer
, SSH2_MSG_CHANNEL_OPEN_FAILURE) < 0) { , SSH2_MSG_CHANNEL_OPEN_FAILURE) < 0) {
@ -686,7 +686,7 @@ static int ssh_message_channel_request_reply_default(ssh_message msg) {
if (msg->channel_request.want_reply) { if (msg->channel_request.want_reply) {
channel = msg->channel_request.channel->remote_channel; channel = msg->channel_request.channel->remote_channel;
ssh_log(msg->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sending a default channel_request denied to channel %d", channel); "Sending a default channel_request denied to channel %d", channel);
if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_CHANNEL_FAILURE) < 0) { if (buffer_add_u8(msg->session->out_buffer, SSH2_MSG_CHANNEL_FAILURE) < 0) {
@ -699,7 +699,7 @@ static int ssh_message_channel_request_reply_default(ssh_message msg) {
return packet_send(msg->session); return packet_send(msg->session);
} }
ssh_log(msg->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"The client doesn't want to know the request failed!"); "The client doesn't want to know the request failed!");
return SSH_OK; return SSH_OK;
@ -719,7 +719,7 @@ int ssh_message_service_reply_success(ssh_message msg) {
} }
session = msg->session; session = msg->session;
ssh_log(session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sending a SERVICE_ACCEPT for service %s", msg->service_request.service); "Sending a SERVICE_ACCEPT for service %s", msg->service_request.service);
if (buffer_add_u8(session->out_buffer, SSH2_MSG_SERVICE_ACCEPT) < 0) { if (buffer_add_u8(session->out_buffer, SSH2_MSG_SERVICE_ACCEPT) < 0) {
return -1; return -1;
@ -738,7 +738,7 @@ int ssh_message_service_reply_success(ssh_message msg) {
} }
int ssh_message_global_request_reply_success(ssh_message msg, uint16_t bound_port) { int ssh_message_global_request_reply_success(ssh_message msg, uint16_t bound_port) {
ssh_log(msg->session, SSH_LOG_FUNCTIONS, "Accepting a global request"); SSH_LOG(SSH_LOG_FUNCTIONS, "Accepting a global request");
if (msg->global_request.want_reply) { if (msg->global_request.want_reply) {
if (buffer_add_u8(msg->session->out_buffer if (buffer_add_u8(msg->session->out_buffer
@ -758,7 +758,7 @@ int ssh_message_global_request_reply_success(ssh_message msg, uint16_t bound_por
if(msg->global_request.type == SSH_GLOBAL_REQUEST_TCPIP_FORWARD if(msg->global_request.type == SSH_GLOBAL_REQUEST_TCPIP_FORWARD
&& msg->global_request.bind_port == 0) { && msg->global_request.bind_port == 0) {
ssh_log(msg->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"The client doesn't want to know the remote port!"); "The client doesn't want to know the remote port!");
} }
@ -768,7 +768,7 @@ error:
} }
static int ssh_message_global_request_reply_default(ssh_message msg) { static int ssh_message_global_request_reply_default(ssh_message msg) {
ssh_log(msg->session, SSH_LOG_FUNCTIONS, "Refusing a global request"); SSH_LOG(SSH_LOG_FUNCTIONS, "Refusing a global request");
if (msg->global_request.want_reply) { if (msg->global_request.want_reply) {
if (buffer_add_u8(msg->session->out_buffer if (buffer_add_u8(msg->session->out_buffer
@ -777,7 +777,7 @@ static int ssh_message_global_request_reply_default(ssh_message msg) {
} }
return packet_send(msg->session); return packet_send(msg->session);
} }
ssh_log(msg->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"The client doesn't want to know the request failed!"); "The client doesn't want to know the request failed!");
return SSH_OK; return SSH_OK;
@ -802,7 +802,7 @@ int ssh_message_reply_default(ssh_message msg) {
case SSH_REQUEST_GLOBAL: case SSH_REQUEST_GLOBAL:
return ssh_message_global_request_reply_default(msg); return ssh_message_global_request_reply_default(msg);
default: default:
ssh_log(msg->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Don't know what to default reply to %d type", "Don't know what to default reply to %d type",
msg->type); msg->type);
break; break;
@ -958,7 +958,7 @@ int ssh_message_auth_interactive_request(ssh_message msg, const char *name,
/* fill in the kbdint structure */ /* fill in the kbdint structure */
if (msg->session->kbdint == NULL) { if (msg->session->kbdint == NULL) {
ssh_log(msg->session, SSH_LOG_PROTOCOL, "Warning: Got a " SSH_LOG(SSH_LOG_PROTOCOL, "Warning: Got a "
"keyboard-interactive response but it " "keyboard-interactive response but it "
"seems we didn't send the request."); "seems we didn't send the request.");
@ -1043,11 +1043,11 @@ int ssh_auth_reply_success(ssh_session session, int partial) {
r = packet_send(session); r = packet_send(session);
if(session->current_crypto && session->current_crypto->delayed_compress_out){ if(session->current_crypto && session->current_crypto->delayed_compress_out){
ssh_log(session,SSH_LOG_PROTOCOL,"Enabling delayed compression OUT"); SSH_LOG(SSH_LOG_PROTOCOL,"Enabling delayed compression OUT");
session->current_crypto->do_compress_out=1; session->current_crypto->do_compress_out=1;
} }
if(session->current_crypto && session->current_crypto->delayed_compress_in){ if(session->current_crypto && session->current_crypto->delayed_compress_in){
ssh_log(session,SSH_LOG_PROTOCOL,"Enabling delayed compression IN"); SSH_LOG(SSH_LOG_PROTOCOL,"Enabling delayed compression IN");
session->current_crypto->do_compress_in=1; session->current_crypto->do_compress_in=1;
} }
return r; return r;

2
src/session.c
View File

@ -641,7 +641,7 @@ int ssh_get_version(ssh_session session) {
void ssh_socket_exception_callback(int code, int errno_code, void *user){ void ssh_socket_exception_callback(int code, int errno_code, void *user){
ssh_session session=(ssh_session)user; ssh_session session=(ssh_session)user;
enter_function(); enter_function();
ssh_log(session,SSH_LOG_RARE,"Socket exception callback: %d (%d)",code, errno_code); SSH_LOG(SSH_LOG_RARE,"Socket exception callback: %d (%d)",code, errno_code);
session->session_state=SSH_SESSION_STATE_ERROR; session->session_state=SSH_SESSION_STATE_ERROR;
ssh_set_error(session,SSH_FATAL,"Socket error: %s",strerror(errno_code)); ssh_set_error(session,SSH_FATAL,"Socket error: %s",strerror(errno_code));
session->ssh_connection_callback(session); session->ssh_connection_callback(session);

32
src/sftp.c
View File

@ -217,11 +217,11 @@ int sftp_server_init(sftp_session sftp){
return -1; return -1;
} }
ssh_log(session, SSH_LOG_PACKET, "Received SSH_FXP_INIT"); SSH_LOG(SSH_LOG_PACKET, "Received SSH_FXP_INIT");
buffer_get_u32(packet->payload, &version); buffer_get_u32(packet->payload, &version);
version = ntohl(version); version = ntohl(version);
ssh_log(session, SSH_LOG_PACKET, "Client version: %d", version); SSH_LOG(SSH_LOG_PACKET, "Client version: %d", version);
sftp->client_version = version; sftp->client_version = version;
sftp_packet_free(packet); sftp_packet_free(packet);
@ -244,7 +244,7 @@ int sftp_server_init(sftp_session sftp){
} }
ssh_buffer_free(reply); ssh_buffer_free(reply);
ssh_log(session, SSH_LOG_RARE, "Server version sent"); SSH_LOG(SSH_LOG_RARE, "Server version sent");
if (version > LIBSFTP_VERSION) { if (version > LIBSFTP_VERSION) {
sftp->version = LIBSFTP_VERSION; sftp->version = LIBSFTP_VERSION;
@ -302,7 +302,7 @@ int sftp_packet_write(sftp_session sftp, uint8_t type, ssh_buffer payload){
if (size < 0) { if (size < 0) {
return -1; return -1;
} else if((uint32_t) size != buffer_get_rest_len(payload)) { } else if((uint32_t) size != buffer_get_rest_len(payload)) {
ssh_log(sftp->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Had to write %d bytes, wrote only %d", "Had to write %d bytes, wrote only %d",
buffer_get_rest_len(payload), buffer_get_rest_len(payload),
size); size);
@ -450,7 +450,7 @@ static sftp_message sftp_get_message(sftp_packet packet) {
return NULL; return NULL;
} }
ssh_log(packet->sftp->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Packet with id %d type %d", "Packet with id %d type %d",
msg->id, msg->id,
msg->packet_type); msg->packet_type);
@ -539,7 +539,7 @@ int sftp_init(sftp_session sftp) {
/* TODO: are we sure there are 4 bytes ready? */ /* TODO: are we sure there are 4 bytes ready? */
buffer_get_u32(packet->payload, &version); buffer_get_u32(packet->payload, &version);
version = ntohl(version); version = ntohl(version);
ssh_log(sftp->session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"SFTP server version %d", "SFTP server version %d",
version); version);
@ -564,7 +564,7 @@ int sftp_init(sftp_session sftp) {
ssh_string_free(ext_data_s); ssh_string_free(ext_data_s);
return -1; return -1;
} }
ssh_log(sftp->session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"SFTP server extension: %s, version: %s", "SFTP server extension: %s, version: %s",
ext_name, ext_data); ext_name, ext_data);
@ -705,7 +705,7 @@ static int sftp_enqueue(sftp_session sftp, sftp_message msg) {
return -1; return -1;
} }
ssh_log(sftp->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Queued msg type %d id %d", "Queued msg type %d id %d",
msg->id, msg->packet_type); msg->id, msg->packet_type);
@ -746,7 +746,7 @@ static sftp_message sftp_dequeue(sftp_session sftp, uint32_t id){
} }
msg = queue->message; msg = queue->message;
request_queue_free(queue); request_queue_free(queue);
ssh_log(sftp->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Dequeued msg id %d type %d", "Dequeued msg id %d type %d",
msg->id, msg->id,
msg->packet_type); msg->packet_type);
@ -1222,7 +1222,7 @@ static sftp_attributes sftp_parse_attr_3(sftp_session sftp, ssh_buffer buf,
break; break;
} }
ssh_log(sftp->session, SSH_LOG_RARE, "Name: %s", attr->name); SSH_LOG(SSH_LOG_RARE, "Name: %s", attr->name);
longname = buffer_get_ssh_string(buf); longname = buffer_get_ssh_string(buf);
if (longname == NULL) { if (longname == NULL) {
@ -1253,7 +1253,7 @@ static sftp_attributes sftp_parse_attr_3(sftp_session sftp, ssh_buffer buf,
} }
flags = ntohl(flags); flags = ntohl(flags);
attr->flags = flags; attr->flags = flags;
ssh_log(sftp->session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"Flags: %.8lx\n", (long unsigned int) flags); "Flags: %.8lx\n", (long unsigned int) flags);
if (flags & SSH_FILEXFER_ATTR_SIZE) { if (flags & SSH_FILEXFER_ATTR_SIZE) {
@ -1261,7 +1261,7 @@ static sftp_attributes sftp_parse_attr_3(sftp_session sftp, ssh_buffer buf,
break; break;
} }
attr->size = ntohll(attr->size); attr->size = ntohll(attr->size);
ssh_log(sftp->session, SSH_LOG_RARE, SSH_LOG(SSH_LOG_RARE,
"Size: %llu\n", "Size: %llu\n",
(long long unsigned int) attr->size); (long long unsigned int) attr->size);
} }
@ -1450,7 +1450,7 @@ sftp_attributes sftp_readdir(sftp_session sftp, sftp_dir dir) {
} }
ssh_buffer_free(payload); ssh_buffer_free(payload);
ssh_log(sftp->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Sent a ssh_fxp_readdir with id %d", id); "Sent a ssh_fxp_readdir with id %d", id);
while (msg == NULL) { while (msg == NULL) {
@ -1507,7 +1507,7 @@ sftp_attributes sftp_readdir(sftp_session sftp, sftp_dir dir) {
return NULL; return NULL;
} }
ssh_log(sftp->session, SSH_LOG_RARE, "Count is %d", dir->count); SSH_LOG(SSH_LOG_RARE, "Count is %d", dir->count);
attr = sftp_parse_attr(sftp, dir->buffer, 1); attr = sftp_parse_attr(sftp, dir->buffer, 1);
if (attr == NULL) { if (attr == NULL) {
@ -1683,7 +1683,7 @@ sftp_file sftp_open(sftp_session sftp, const char *file, int flags,
sftp_flags |= SSH_FXF_TRUNC; sftp_flags |= SSH_FXF_TRUNC;
if (flags & O_EXCL) if (flags & O_EXCL)
sftp_flags |= SSH_FXF_EXCL; sftp_flags |= SSH_FXF_EXCL;
ssh_log(sftp->session,SSH_LOG_PACKET,"Opening file %s with sftp flags %x",file,sftp_flags); SSH_LOG(SSH_LOG_PACKET,"Opening file %s with sftp flags %x",file,sftp_flags);
id = sftp_get_new_id(sftp); id = sftp_get_new_id(sftp);
if (buffer_add_u32(buffer, id) < 0 || if (buffer_add_u32(buffer, id) < 0 ||
buffer_add_ssh_string(buffer, filename) < 0) { buffer_add_ssh_string(buffer, filename) < 0) {
@ -2002,7 +2002,7 @@ ssize_t sftp_write(sftp_file file, const void *buf, size_t count) {
if (len < 0) { if (len < 0) {
return -1; return -1;
} else if (len != packetlen) { } else if (len != packetlen) {
ssh_log(sftp->session, SSH_LOG_PACKET, SSH_LOG(SSH_LOG_PACKET,
"Could not write as much data as expected"); "Could not write as much data as expected");
} }

10
src/socket.c
View File

@ -305,7 +305,7 @@ int ssh_socket_pollcallback(struct ssh_poll_handle_struct *p, socket_t fd, int r
#endif #endif
/* First, POLLOUT is a sign we may be connected */ /* First, POLLOUT is a sign we may be connected */
if(s->state == SSH_SOCKET_CONNECTING){ if(s->state == SSH_SOCKET_CONNECTING){
ssh_log(s->session,SSH_LOG_PACKET,"Received POLLOUT in connecting state"); SSH_LOG(SSH_LOG_PACKET,"Received POLLOUT in connecting state");
s->state = SSH_SOCKET_CONNECTED; s->state = SSH_SOCKET_CONNECTED;
ssh_poll_set_events(p,POLLOUT | POLLIN); ssh_poll_set_events(p,POLLOUT | POLLIN);
r = ssh_socket_set_blocking(ssh_socket_get_fd_in(s)); r = ssh_socket_set_blocking(ssh_socket_get_fd_in(s));
@ -543,7 +543,7 @@ static int ssh_socket_unbuffered_write(ssh_socket s, const void *buffer,
s->write_wontblock = 0; s->write_wontblock = 0;
/* Reactive the POLLOUT detector in the poll multiplexer system */ /* Reactive the POLLOUT detector in the poll multiplexer system */
if(s->poll_out){ if(s->poll_out){
ssh_log(s->session, SSH_LOG_PACKET, "Enabling POLLOUT for socket"); SSH_LOG(SSH_LOG_PACKET, "Enabling POLLOUT for socket");
ssh_poll_set_events(s->poll_out,ssh_poll_get_events(s->poll_out) | POLLOUT); ssh_poll_set_events(s->poll_out,ssh_poll_get_events(s->poll_out) | POLLOUT);
} }
if (w < 0) { if (w < 0) {
@ -762,7 +762,7 @@ int ssh_socket_connect(ssh_socket s, const char *host, int port, const char *bin
return SSH_ERROR; return SSH_ERROR;
} }
fd=ssh_connect_host_nonblocking(s->session,host,bind_addr,port); fd=ssh_connect_host_nonblocking(s->session,host,bind_addr,port);
ssh_log(session,SSH_LOG_PROTOCOL,"Nonblocking connection socket: %d",fd); SSH_LOG(SSH_LOG_PROTOCOL,"Nonblocking connection socket: %d",fd);
if(fd == SSH_INVALID_SOCKET) if(fd == SSH_INVALID_SOCKET)
return SSH_ERROR; return SSH_ERROR;
ssh_socket_set_fd(s,fd); ssh_socket_set_fd(s,fd);
@ -825,14 +825,14 @@ int ssh_socket_connect_proxycommand(ssh_socket s, const char *command){
return SSH_ERROR; return SSH_ERROR;
} }
ssh_log(session,SSH_LOG_PROTOCOL,"Executing proxycommand '%s'",command); SSH_LOG(SSH_LOG_PROTOCOL,"Executing proxycommand '%s'",command);
pid = fork(); pid = fork();
if(pid == 0){ if(pid == 0){
ssh_execute_command(command,out_pipe[0],in_pipe[1]); ssh_execute_command(command,out_pipe[0],in_pipe[1]);
} }
close(in_pipe[1]); close(in_pipe[1]);
close(out_pipe[0]); close(out_pipe[0]);
ssh_log(session,SSH_LOG_PROTOCOL,"ProxyCommand connection pipe: [%d,%d]",in_pipe[0],out_pipe[1]); SSH_LOG(SSH_LOG_PROTOCOL,"ProxyCommand connection pipe: [%d,%d]",in_pipe[0],out_pipe[1]);
ssh_socket_set_fd_in(s,in_pipe[0]); ssh_socket_set_fd_in(s,in_pipe[0]);
ssh_socket_set_fd_out(s,out_pipe[1]); ssh_socket_set_fd_out(s,out_pipe[1]);
s->state=SSH_SOCKET_CONNECTED; s->state=SSH_SOCKET_CONNECTED;

12
src/wrapper.c
View File

@ -183,7 +183,7 @@ static int crypt_set_algorithms2(ssh_session session){
wanted); wanted);
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, "Set output algorithm to %s", wanted); SSH_LOG(SSH_LOG_PACKET, "Set output algorithm to %s", wanted);
session->next_crypto->out_cipher = cipher_new(i); session->next_crypto->out_cipher = cipher_new(i);
if (session->next_crypto->out_cipher == NULL) { if (session->next_crypto->out_cipher == NULL) {
@ -204,7 +204,7 @@ static int crypt_set_algorithms2(ssh_session session){
wanted); wanted);
goto error; goto error;
} }
ssh_log(session, SSH_LOG_PACKET, "Set input algorithm to %s", wanted); SSH_LOG(SSH_LOG_PACKET, "Set input algorithm to %s", wanted);
session->next_crypto->in_cipher = cipher_new(i); session->next_crypto->in_cipher = cipher_new(i);
if (session->next_crypto->in_cipher == NULL) { if (session->next_crypto->in_cipher == NULL) {
@ -288,7 +288,7 @@ int crypt_set_algorithms_server(ssh_session session){
"no crypto algorithm function found for %s",method); "no crypto algorithm function found for %s",method);
goto error; goto error;
} }
ssh_log(session,SSH_LOG_PACKET,"Set output algorithm %s",method); SSH_LOG(SSH_LOG_PACKET,"Set output algorithm %s",method);
session->next_crypto->out_cipher = cipher_new(i); session->next_crypto->out_cipher = cipher_new(i);
if (session->next_crypto->out_cipher == NULL) { if (session->next_crypto->out_cipher == NULL) {
@ -305,7 +305,7 @@ int crypt_set_algorithms_server(ssh_session session){
"no crypto algorithm function found for %s",method); "no crypto algorithm function found for %s",method);
goto error; goto error;
} }
ssh_log(session,SSH_LOG_PACKET,"Set input algorithm %s",method); SSH_LOG(SSH_LOG_PACKET,"Set input algorithm %s",method);
session->next_crypto->in_cipher = cipher_new(i); session->next_crypto->in_cipher = cipher_new(i);
if (session->next_crypto->in_cipher == NULL) { if (session->next_crypto->in_cipher == NULL) {
@ -316,7 +316,7 @@ int crypt_set_algorithms_server(ssh_session session){
/* compression */ /* compression */
method = session->next_crypto->kex_methods[SSH_CRYPT_C_S]; method = session->next_crypto->kex_methods[SSH_CRYPT_C_S];
if(strcmp(method,"zlib") == 0){ if(strcmp(method,"zlib") == 0){
ssh_log(session,SSH_LOG_PACKET,"enabling C->S compression"); SSH_LOG(SSH_LOG_PACKET,"enabling C->S compression");
session->next_crypto->do_compress_in=1; session->next_crypto->do_compress_in=1;
} }
if(strcmp(method,"zlib@openssh.com") == 0){ if(strcmp(method,"zlib@openssh.com") == 0){
@ -325,7 +325,7 @@ int crypt_set_algorithms_server(ssh_session session){
} }
method = session->next_crypto->kex_methods[SSH_CRYPT_S_C]; method = session->next_crypto->kex_methods[SSH_CRYPT_S_C];
if(strcmp(method,"zlib") == 0){ if(strcmp(method,"zlib") == 0){
ssh_log(session,SSH_LOG_PACKET,"enabling S->C compression\n"); SSH_LOG(SSH_LOG_PACKET, "enabling S->C compression\n");
session->next_crypto->do_compress_out=1; session->next_crypto->do_compress_out=1;
} }
if(strcmp(method,"zlib@openssh.com") == 0){ if(strcmp(method,"zlib@openssh.com") == 0){