generic-library/ssh2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Use LIBSSH2_TRACE_* internally and remove redundant LIBSSH2_DBG_*

Browse Source
This commit is contained in:
Peter Stuge 2009-12-08 08:52:03 +01:00
parent 1a491c6f00
commit d142f385da
11 changed files with 167 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/channel.c
View File

@ -78,7 +78,7 @@ _libssh2_channel_nextid(LIBSSH2_SESSION * session)
* told... * told...
*/ */
session->next_channel = id + 1; session->next_channel = id + 1;
_libssh2_debug(session, LIBSSH2_DBG_CONN, "Allocated new channel ID#%lu", _libssh2_debug(session, LIBSSH2_TRACE_CONN, "Allocated new channel ID#%lu",
id); id);
return id; return id;
} }
@ -149,7 +149,7 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
memset(&session->open_packet_requirev_state, 0, memset(&session->open_packet_requirev_state, 0,
sizeof(session->open_packet_requirev_state)); sizeof(session->open_packet_requirev_state));
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Opening Channel - win %d pack %d", window_size, "Opening Channel - win %d pack %d", window_size,
packet_size); packet_size);
session->open_channel = session->open_channel =
@ -254,7 +254,7 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
_libssh2_ntohu32(session->open_data + 9); _libssh2_ntohu32(session->open_data + 9);
session->open_channel->local.packet_size = session->open_channel->local.packet_size =
_libssh2_ntohu32(session->open_data + 13); _libssh2_ntohu32(session->open_data + 13);
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Connection Established - ID: %lu/%lu win: %lu/%lu" "Connection Established - ID: %lu/%lu win: %lu/%lu"
" pack: %lu/%lu", " pack: %lu/%lu",
session->open_channel->local.id, session->open_channel->local.id,
@ -361,7 +361,7 @@ channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host,
session->direct_message_len = session->direct_message_len =
session->direct_host_len + session->direct_shost_len + 16; session->direct_host_len + session->direct_shost_len + 16;
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Requesting direct-tcpip session to from %s:%d to %s:%d", "Requesting direct-tcpip session to from %s:%d to %s:%d",
shost, sport, host, port); shost, sport, host, port);
@ -455,7 +455,7 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
memset(&session->fwdLstn_packet_requirev_state, 0, memset(&session->fwdLstn_packet_requirev_state, 0,
sizeof(session->fwdLstn_packet_requirev_state)); sizeof(session->fwdLstn_packet_requirev_state));
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Requesting tcpip-forward session for %s:%d", host, "Requesting tcpip-forward session for %s:%d", host,
port); port);
@ -552,7 +552,7 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
listener->host[session->fwdLstn_host_len] = 0; listener->host[session->fwdLstn_host_len] = 0;
if (data_len >= 5 && !port) { if (data_len >= 5 && !port) {
listener->port = _libssh2_ntohu32(data + 1); listener->port = _libssh2_ntohu32(data + 1);
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Dynamic tcpip-forward port allocated: %d", "Dynamic tcpip-forward port allocated: %d",
listener->port); listener->port);
} else { } else {
@ -625,7 +625,7 @@ static int channel_forward_cancel(LIBSSH2_LISTENER *listener)
int rc; int rc;
if (listener->chanFwdCncl_state == libssh2_NB_state_idle) { if (listener->chanFwdCncl_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Cancelling tcpip-forward session for %s:%d", "Cancelling tcpip-forward session for %s:%d",
listener->host, listener->port); listener->host, listener->port);
@ -791,7 +791,7 @@ static int channel_setenv(LIBSSH2_CHANNEL *channel,
memset(&channel->setenv_packet_requirev_state, 0, memset(&channel->setenv_packet_requirev_state, 0,
sizeof(channel->setenv_packet_requirev_state)); sizeof(channel->setenv_packet_requirev_state));
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Setting remote environment variable: %s=%s on " "Setting remote environment variable: %s=%s on "
"channel %lu/%lu", "channel %lu/%lu",
varname, value, channel->local.id, channel->remote.id); varname, value, channel->local.id, channel->remote.id);
@ -922,7 +922,7 @@ static int channel_request_pty(LIBSSH2_CHANNEL *channel,
memset(&channel->reqPTY_packet_requirev_state, 0, memset(&channel->reqPTY_packet_requirev_state, 0,
sizeof(channel->reqPTY_packet_requirev_state)); sizeof(channel->reqPTY_packet_requirev_state));
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Allocating tty on channel %lu/%lu", channel->local.id, "Allocating tty on channel %lu/%lu", channel->local.id,
channel->remote.id); channel->remote.id);
@ -1049,7 +1049,7 @@ channel_request_pty_size(LIBSSH2_CHANNEL * channel, int width,
memset(&channel->reqPTY_packet_requirev_state, 0, memset(&channel->reqPTY_packet_requirev_state, 0,
sizeof(channel->reqPTY_packet_requirev_state)); sizeof(channel->reqPTY_packet_requirev_state));
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"changing tty size on channel %lu/%lu", "changing tty size on channel %lu/%lu",
channel->local.id, channel->local.id,
channel->remote.id); channel->remote.id);
@ -1153,7 +1153,7 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
memset(&channel->reqX11_packet_requirev_state, 0, memset(&channel->reqX11_packet_requirev_state, 0,
sizeof(channel->reqX11_packet_requirev_state)); sizeof(channel->reqX11_packet_requirev_state));
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Requesting x11-req for channel %lu/%lu: single=%d " "Requesting x11-req for channel %lu/%lu: single=%d "
"proto=%s cookie=%s screen=%d", "proto=%s cookie=%s screen=%d",
channel->local.id, channel->remote.id, channel->local.id, channel->remote.id,
@ -1303,7 +1303,7 @@ _libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
channel->process_packet_len += message_len + 4; channel->process_packet_len += message_len + 4;
} }
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"starting request(%s) on channel %lu/%lu, message=%s", "starting request(%s) on channel %lu/%lu, message=%s",
request, channel->local.id, channel->remote.id, request, channel->local.id, channel->remote.id,
message); message);
@ -1449,7 +1449,7 @@ _libssh2_channel_flush(LIBSSH2_CHANNEL *channel, int streamid)
&& (streamid == 0))) { && (streamid == 0))) {
int bytes_to_flush = packet->data_len - packet->data_head; int bytes_to_flush = packet->data_len - packet->data_head;
_libssh2_debug(channel->session, LIBSSH2_DBG_CONN, _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
"Flushing %d bytes of data from stream " "Flushing %d bytes of data from stream "
"%lu on channel %lu/%lu", "%lu on channel %lu/%lu",
bytes_to_flush, packet_stream_id, bytes_to_flush, packet_stream_id,
@ -1533,7 +1533,7 @@ _libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
if (!force if (!force
&& (adjustment + channel->adjust_queue < && (adjustment + channel->adjust_queue <
LIBSSH2_CHANNEL_MINADJUST)) { LIBSSH2_CHANNEL_MINADJUST)) {
_libssh2_debug(channel->session, LIBSSH2_DBG_CONN, _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
"Queueing %lu bytes for receive window adjustment " "Queueing %lu bytes for receive window adjustment "
"for channel %lu/%lu", "for channel %lu/%lu",
adjustment, channel->local.id, channel->remote.id); adjustment, channel->local.id, channel->remote.id);
@ -1556,7 +1556,7 @@ _libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
channel->adjust_adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST; channel->adjust_adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST;
_libssh2_htonu32(&channel->adjust_adjust[1], channel->remote.id); _libssh2_htonu32(&channel->adjust_adjust[1], channel->remote.id);
_libssh2_htonu32(&channel->adjust_adjust[5], adjustment); _libssh2_htonu32(&channel->adjust_adjust[5], adjustment);
_libssh2_debug(channel->session, LIBSSH2_DBG_CONN, _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
"Adjusting window %lu bytes for data on " "Adjusting window %lu bytes for data on "
"channel %lu/%lu", "channel %lu/%lu",
adjustment, channel->local.id, channel->remote.id); adjustment, channel->local.id, channel->remote.id);
@ -1643,7 +1643,7 @@ int
_libssh2_channel_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode) _libssh2_channel_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode)
{ {
if (channel->extData2_state == libssh2_NB_state_idle) { if (channel->extData2_state == libssh2_NB_state_idle) {
_libssh2_debug(channel->session, LIBSSH2_DBG_CONN, _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
"Setting channel %lu/%lu handle_extended_data" "Setting channel %lu/%lu handle_extended_data"
" mode to %d", " mode to %d",
channel->local.id, channel->remote.id, ignore_mode); channel->local.id, channel->remote.id, ignore_mode);
@ -1720,7 +1720,7 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
LIBSSH2_PACKET *read_next; LIBSSH2_PACKET *read_next;
if (channel->read_state == libssh2_NB_state_idle) { if (channel->read_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"channel_read() wants %d bytes from channel %lu/%lu " "channel_read() wants %d bytes from channel %lu/%lu "
"stream #%d", "stream #%d",
(int) buflen, channel->local.id, channel->remote.id, (int) buflen, channel->local.id, channel->remote.id,
@ -1797,7 +1797,7 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
unlink_packet = TRUE; unlink_packet = TRUE;
} }
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"channel_read() got %d of data from %lu/%lu/%d%s", "channel_read() got %d of data from %lu/%lu/%d%s",
bytes_want, channel->local.id, bytes_want, channel->local.id,
channel->remote.id, stream_id, channel->remote.id, stream_id,
@ -1856,7 +1856,7 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
if (rc == PACKET_EAGAIN) if (rc == PACKET_EAGAIN)
return rc; return rc;
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"channel_read() filled %d adjusted %d", "channel_read() filled %d adjusted %d",
bytes_read, buflen); bytes_read, buflen);
/* continue in 'created' state to drain the already read packages /* continue in 'created' state to drain the already read packages
@ -1966,7 +1966,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
if (channel->write_state == libssh2_NB_state_idle) { if (channel->write_state == libssh2_NB_state_idle) {
channel->write_bufwrote = 0; channel->write_bufwrote = 0;
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Writing %d bytes on channel %lu/%lu, stream #%d", "Writing %d bytes on channel %lu/%lu, stream #%d",
(int) buflen, channel->local.id, channel->remote.id, (int) buflen, channel->local.id, channel->remote.id,
stream_id); stream_id);
@ -2030,7 +2030,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
/* Don't exceed the remote end's limits */ /* Don't exceed the remote end's limits */
/* REMEMBER local means local as the SOURCE of the data */ /* REMEMBER local means local as the SOURCE of the data */
if (channel->write_bufwrite > channel->local.window_size) { if (channel->write_bufwrite > channel->local.window_size) {
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Splitting write block due to %lu byte " "Splitting write block due to %lu byte "
"window_size on %lu/%lu/%d", "window_size on %lu/%lu/%d",
channel->local.window_size, channel->local.id, channel->local.window_size, channel->local.id,
@ -2038,7 +2038,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
channel->write_bufwrite = channel->local.window_size; channel->write_bufwrite = channel->local.window_size;
} }
if (channel->write_bufwrite > channel->local.packet_size) { if (channel->write_bufwrite > channel->local.packet_size) {
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Splitting write block due to %lu byte " "Splitting write block due to %lu byte "
"packet_size on %lu/%lu/%d", "packet_size on %lu/%lu/%d",
channel->local.packet_size, channel->local.id, channel->local.packet_size, channel->local.id,
@ -2050,7 +2050,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
memcpy(channel->write_s, buf, channel->write_bufwrite); memcpy(channel->write_s, buf, channel->write_bufwrite);
channel->write_s += channel->write_bufwrite; channel->write_s += channel->write_bufwrite;
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Sending %d bytes on channel %lu/%lu, stream_id=%d", "Sending %d bytes on channel %lu/%lu, stream_id=%d",
(int) channel->write_bufwrite, channel->local.id, (int) channel->write_bufwrite, channel->local.id,
channel->remote.id, stream_id); channel->remote.id, stream_id);
@ -2122,7 +2122,7 @@ static int channel_send_eof(LIBSSH2_CHANNEL *channel)
unsigned char packet[5]; /* packet_type(1) + channelno(4) */ unsigned char packet[5]; /* packet_type(1) + channelno(4) */
int rc; int rc;
_libssh2_debug(session, LIBSSH2_DBG_CONN, "Sending EOF on channel %lu/%lu", _libssh2_debug(session, LIBSSH2_TRACE_CONN, "Sending EOF on channel %lu/%lu",
channel->local.id, channel->remote.id); channel->local.id, channel->remote.id);
packet[0] = SSH_MSG_CHANNEL_EOF; packet[0] = SSH_MSG_CHANNEL_EOF;
_libssh2_htonu32(packet + 1, channel->remote.id); _libssh2_htonu32(packet + 1, channel->remote.id);
@ -2188,7 +2188,7 @@ static int channel_wait_eof(LIBSSH2_CHANNEL *channel)
int rc; int rc;
if (channel->wait_eof_state == libssh2_NB_state_idle) { if (channel->wait_eof_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Awaiting close of channel %lu/%lu", channel->local.id, "Awaiting close of channel %lu/%lu", channel->local.id,
channel->remote.id); channel->remote.id);
@ -2246,7 +2246,7 @@ channel_close(LIBSSH2_CHANNEL * channel)
} }
if (channel->close_state == libssh2_NB_state_idle) { if (channel->close_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_CONN, "Closing channel %lu/%lu", _libssh2_debug(session, LIBSSH2_TRACE_CONN, "Closing channel %lu/%lu",
channel->local.id, channel->remote.id); channel->local.id, channel->remote.id);
channel->close_packet[0] = SSH_MSG_CHANNEL_CLOSE; channel->close_packet[0] = SSH_MSG_CHANNEL_CLOSE;
@ -2327,7 +2327,7 @@ static int channel_wait_closed(LIBSSH2_CHANNEL *channel)
} }
if (channel->wait_closed_state == libssh2_NB_state_idle) { if (channel->wait_closed_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Awaiting close of channel %lu/%lu", channel->local.id, "Awaiting close of channel %lu/%lu", channel->local.id,
channel->remote.id); channel->remote.id);
@ -2386,7 +2386,7 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
assert(session); assert(session);
if (channel->free_state == libssh2_NB_state_idle) { if (channel->free_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Freeing channel %lu/%lu resources", channel->local.id, "Freeing channel %lu/%lu resources", channel->local.id,
channel->remote.id); channel->remote.id);

72
src/kex.c
View File

@ -135,7 +135,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
exchange_state->e_packet + 6); exchange_state->e_packet + 6);
} }
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sending KEX packet %d", _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sending KEX packet %d",
(int) packet_type_init); (int) packet_type_init);
exchange_state->state = libssh2_NB_state_created; exchange_state->state = libssh2_NB_state_created;
} }
@ -161,7 +161,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
* need to silently ignore it */ * need to silently ignore it */
int burn_type; int burn_type;
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Waiting for badly guessed KEX packet (to be ignored)"); "Waiting for badly guessed KEX packet (to be ignored)");
burn_type = burn_type =
_libssh2_packet_burn(session, &exchange_state->burn_state); _libssh2_packet_burn(session, &exchange_state->burn_state);
@ -174,7 +174,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
} }
session->burn_optimistic_kexinit = 0; session->burn_optimistic_kexinit = 0;
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Burnt packet of type: %02x", "Burnt packet of type: %02x",
(unsigned int) burn_type); (unsigned int) burn_type);
} }
@ -233,7 +233,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
snprintf(fprint, 4, "%02x:", session->server_hostkey_md5[i]); snprintf(fprint, 4, "%02x:", session->server_hostkey_md5[i]);
} }
*(--fprint) = '\0'; *(--fprint) = '\0';
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Server's MD5 Fingerprint: %s", fingerprint); "Server's MD5 Fingerprint: %s", fingerprint);
} }
#endif /* LIBSSH2DEBUG */ #endif /* LIBSSH2DEBUG */
@ -256,7 +256,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
snprintf(fprint, 4, "%02x:", session->server_hostkey_sha1[i]); snprintf(fprint, 4, "%02x:", session->server_hostkey_sha1[i]);
} }
*(--fprint) = '\0'; *(--fprint) = '\0';
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Server's SHA1 Fingerprint: %s", fingerprint); "Server's SHA1 Fingerprint: %s", fingerprint);
} }
#endif /* LIBSSH2DEBUG */ #endif /* LIBSSH2DEBUG */
@ -410,7 +410,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
goto clean_exit; goto clean_exit;
} }
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sending NEWKEYS message"); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sending NEWKEYS message");
exchange_state->c = SSH_MSG_NEWKEYS; exchange_state->c = SSH_MSG_NEWKEYS;
exchange_state->state = libssh2_NB_state_sent2; exchange_state->state = libssh2_NB_state_sent2;
@ -444,7 +444,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
/* The first key exchange has been performed, /* The first key exchange has been performed,
switch to active crypt/comp/mac mode */ switch to active crypt/comp/mac mode */
session->state |= LIBSSH2_STATE_NEWKEYS; session->state |= LIBSSH2_STATE_NEWKEYS;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Received NEWKEYS message"); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Received NEWKEYS message");
/* This will actually end up being just packet_type(1) /* This will actually end up being just packet_type(1)
for this packet type anyway */ for this packet type anyway */
@ -461,7 +461,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
memcpy(session->session_id, exchange_state->h_sig_comp, memcpy(session->session_id, exchange_state->h_sig_comp,
SHA_DIGEST_LENGTH); SHA_DIGEST_LENGTH);
session->session_id_len = SHA_DIGEST_LENGTH; session->session_id_len = SHA_DIGEST_LENGTH;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "session_id calculated"); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "session_id calculated");
} }
/* Cleanup any existing cipher */ /* Cleanup any existing cipher */
@ -509,7 +509,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
LIBSSH2_FREE(session, secret); LIBSSH2_FREE(session, secret);
} }
} }
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Client to Server IV and Key calculated"); "Client to Server IV and Key calculated");
if (session->remote.crypt->dtor) { if (session->remote.crypt->dtor) {
@ -556,7 +556,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
LIBSSH2_FREE(session, secret); LIBSSH2_FREE(session, secret);
} }
} }
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Server to Client IV and Key calculated"); "Server to Client IV and Key calculated");
if (session->local.mac->dtor) { if (session->local.mac->dtor) {
@ -582,7 +582,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
LIBSSH2_FREE(session, key); LIBSSH2_FREE(session, key);
} }
} }
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Client to Server HMAC Key calculated"); "Client to Server HMAC Key calculated");
if (session->remote.mac->dtor) { if (session->remote.mac->dtor) {
@ -608,7 +608,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
LIBSSH2_FREE(session, key); LIBSSH2_FREE(session, key);
} }
} }
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Server to Client HMAC Key calculated"); "Server to Client HMAC Key calculated");
} }
@ -684,7 +684,7 @@ kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SESSION *session,
_libssh2_bn_set_word(key_state->g, 2); _libssh2_bn_set_word(key_state->g, 2);
_libssh2_bn_from_bin(key_state->p, 128, p_value); _libssh2_bn_from_bin(key_state->p, 128, p_value);
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Initiating Diffie-Hellman Group1 Key Exchange"); "Initiating Diffie-Hellman Group1 Key Exchange");
key_state->state = libssh2_NB_state_created; key_state->state = libssh2_NB_state_created;
@ -760,7 +760,7 @@ kex_method_diffie_hellman_group14_sha1_key_exchange(LIBSSH2_SESSION *session,
_libssh2_bn_set_word(key_state->g, 2); _libssh2_bn_set_word(key_state->g, 2);
_libssh2_bn_from_bin(key_state->p, 256, p_value); _libssh2_bn_from_bin(key_state->p, 256, p_value);
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Initiating Diffie-Hellman Group14 Key Exchange"); "Initiating Diffie-Hellman Group14 Key Exchange");
key_state->state = libssh2_NB_state_created; key_state->state = libssh2_NB_state_created;
@ -806,13 +806,13 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
_libssh2_htonu32(key_state->request + 5, LIBSSH2_DH_GEX_OPTGROUP); _libssh2_htonu32(key_state->request + 5, LIBSSH2_DH_GEX_OPTGROUP);
_libssh2_htonu32(key_state->request + 9, LIBSSH2_DH_GEX_MAXGROUP); _libssh2_htonu32(key_state->request + 9, LIBSSH2_DH_GEX_MAXGROUP);
key_state->request_len = 13; key_state->request_len = 13;
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Initiating Diffie-Hellman Group-Exchange (New Method)"); "Initiating Diffie-Hellman Group-Exchange (New Method)");
#else #else
key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST_OLD; key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST_OLD;
_libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_OPTGROUP); _libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_OPTGROUP);
key_state->request_len = 5; key_state->request_len = 5;
_libssh2_debug(session, LIBSSH2_DBG_KEX, _libssh2_debug(session, LIBSSH2_TRACE_KEX,
"Initiating Diffie-Hellman Group-Exchange (Old Method)"); "Initiating Diffie-Hellman Group-Exchange (Old Method)");
#endif #endif
@ -1090,25 +1090,25 @@ static int kexinit(LIBSSH2_SESSION * session)
/* Funnily enough, they'll all "appear" to be '\0' terminated */ /* Funnily enough, they'll all "appear" to be '\0' terminated */
unsigned char *p = data + 21; /* type(1) + cookie(16) + len(4) */ unsigned char *p = data + 21; /* type(1) + cookie(16) + len(4) */
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent KEX: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent KEX: %s", p);
p += kex_len + 4; p += kex_len + 4;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent HOSTKEY: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent HOSTKEY: %s", p);
p += hostkey_len + 4; p += hostkey_len + 4;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent CRYPT_CS: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent CRYPT_CS: %s", p);
p += crypt_cs_len + 4; p += crypt_cs_len + 4;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent CRYPT_SC: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent CRYPT_SC: %s", p);
p += crypt_sc_len + 4; p += crypt_sc_len + 4;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent MAC_CS: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent MAC_CS: %s", p);
p += mac_cs_len + 4; p += mac_cs_len + 4;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent MAC_SC: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent MAC_SC: %s", p);
p += mac_sc_len + 4; p += mac_sc_len + 4;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent COMP_CS: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent COMP_CS: %s", p);
p += comp_cs_len + 4; p += comp_cs_len + 4;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent COMP_SC: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent COMP_SC: %s", p);
p += comp_sc_len + 4; p += comp_sc_len + 4;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent LANG_CS: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent LANG_CS: %s", p);
p += lang_cs_len + 4; p += lang_cs_len + 4;
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent LANG_SC: %s", p); _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent LANG_SC: %s", p);
p += lang_sc_len + 4; p += lang_sc_len + 4;
} }
#endif /* LIBSSH2DEBUG */ #endif /* LIBSSH2DEBUG */
@ -1607,24 +1607,24 @@ static int kex_agree_methods(LIBSSH2_SESSION * session, unsigned char *data,
return -1; return -1;
} }
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on KEX method: %s", _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on KEX method: %s",
session->kex->name); session->kex->name);
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on HOSTKEY method: %s", _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on HOSTKEY method: %s",
session->hostkey->name); session->hostkey->name);
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on CRYPT_CS method: %s", _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on CRYPT_CS method: %s",
session->local.crypt->name); session->local.crypt->name);
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on CRYPT_SC method: %s", _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on CRYPT_SC method: %s",
session->remote.crypt->name); session->remote.crypt->name);
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on MAC_CS method: %s", _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on MAC_CS method: %s",
session->local.mac->name); session->local.mac->name);
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on MAC_SC method: %s", _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on MAC_SC method: %s",
session->remote.mac->name); session->remote.mac->name);
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on COMP_CS method: %s", _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on COMP_CS method: %s",
session->local.comp->name); session->local.comp->name);
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on COMP_SC method: %s", _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on COMP_SC method: %s",
session->remote.comp->name); session->remote.comp->name);
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on LANG_CS method:"); /* None yet */ _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on LANG_CS method:"); /* None yet */
_libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on LANG_SC method:"); /* None yet */ _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on LANG_SC method:"); /* None yet */
/* Initialize compression layer */ /* Initialize compression layer */
if (session->local.comp && session->local.comp->init && if (session->local.comp && session->local.comp->init &&

12
src/libssh2_priv.h
View File

@ -1014,16 +1014,6 @@ struct _LIBSSH2_MAC_METHOD
int (*dtor) (LIBSSH2_SESSION * session, void **abstract); int (*dtor) (LIBSSH2_SESSION * session, void **abstract);
}; };
#define LIBSSH2_DBG_TRANS 1
#define LIBSSH2_DBG_KEX 2
#define LIBSSH2_DBG_AUTH 3
#define LIBSSH2_DBG_CONN 4
#define LIBSSH2_DBG_SCP 5
#define LIBSSH2_DBG_SFTP 6
#define LIBSSH2_DBG_ERROR 7
#define LIBSSH2_DBG_PUBLICKEY 8
#define LIBSSH2_DBG_SOCKET 9
#ifdef LIBSSH2DEBUG #ifdef LIBSSH2DEBUG
void _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, void _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format,
...); ...);
@ -1050,7 +1040,7 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
session->err_msglen = strlen(errmsg); \ session->err_msglen = strlen(errmsg); \
session->err_should_free = should_free; \ session->err_should_free = should_free; \
session->err_code = errcode; \ session->err_code = errcode; \
_libssh2_debug(session, LIBSSH2_DBG_ERROR, "%d - %s", session->err_code, session->err_msg); \ _libssh2_debug(session, LIBSSH2_TRACE_ERROR, "%d - %s", session->err_code, session->err_msg); \
} }
#else /* ! LIBSSH2DEBUG */ #else /* ! LIBSSH2DEBUG */

2
src/misc.c
View File

@ -336,7 +336,7 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
if (context < 1 || context >= (int)ARRAY_SIZE(contexts)) { if (context < 1 || context >= (int)ARRAY_SIZE(contexts)) {
context = 0; context = 0;
} }
if (!(session->showmask & (1 << context))) { if (!(session->showmask & context)) {
/* no such output asked for */ /* no such output asked for */
return; return;
} }

34
src/packet.c
View File

@ -108,7 +108,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
listen_state->sport = _libssh2_ntohu32(s); listen_state->sport = _libssh2_ntohu32(s);
s += 4; s += 4;
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Remote received connection from %s:%ld to %s:%ld", "Remote received connection from %s:%ld to %s:%ld",
listen_state->shost, listen_state->sport, listen_state->shost, listen_state->sport,
listen_state->host, listen_state->port); listen_state->host, listen_state->port);
@ -131,7 +131,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
(listen->queue_maxsize <= listen->queue_size)) { (listen->queue_maxsize <= listen->queue_size)) {
/* Queue is full */ /* Queue is full */
failure_code = 4; /* SSH_OPEN_RESOURCE_SHORTAGE */ failure_code = 4; /* SSH_OPEN_RESOURCE_SHORTAGE */
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Listener queue full, ignoring"); "Listener queue full, ignoring");
listen_state->state = libssh2_NB_state_sent; listen_state->state = libssh2_NB_state_sent;
break; break;
@ -183,7 +183,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
listen_state->initial_window_size; listen_state->initial_window_size;
channel->local.packet_size = listen_state->packet_size; channel->local.packet_size = listen_state->packet_size;
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Connection queued: channel %lu/%lu win %lu/%lu packet %lu/%lu", "Connection queued: channel %lu/%lu win %lu/%lu packet %lu/%lu",
channel->local.id, channel->remote.id, channel->local.id, channel->remote.id,
channel->local.window_size, channel->local.window_size,
@ -294,7 +294,7 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
x11open_state->sport = _libssh2_ntohu32(s); x11open_state->sport = _libssh2_ntohu32(s);
s += 4; s += 4;
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"X11 Connection Received from %s:%ld on channel %lu", "X11 Connection Received from %s:%ld on channel %lu",
x11open_state->shost, x11open_state->sport, x11open_state->shost, x11open_state->sport,
x11open_state->sender_channel); x11open_state->sender_channel);
@ -342,7 +342,7 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
channel->local.window_size = x11open_state->initial_window_size; channel->local.window_size = x11open_state->initial_window_size;
channel->local.packet_size = x11open_state->packet_size; channel->local.packet_size = x11open_state->packet_size;
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"X11 Connection established: channel %lu/%lu win %lu/%lu packet %lu/%lu", "X11 Connection established: channel %lu/%lu win %lu/%lu packet %lu/%lu",
channel->local.id, channel->remote.id, channel->local.id, channel->remote.id,
channel->local.window_size, channel->local.window_size,
@ -446,7 +446,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
memset(&session->packAdd_x11open_state, 0, memset(&session->packAdd_x11open_state, 0,
sizeof(session->packAdd_x11open_state)); sizeof(session->packAdd_x11open_state));
_libssh2_debug(session, LIBSSH2_DBG_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"Packet type %d received, length=%d", "Packet type %d received, length=%d",
(int) data[0], (int) datalen); (int) data[0], (int) datalen);
if (macstate == LIBSSH2_MAC_INVALID) { if (macstate == LIBSSH2_MAC_INVALID) {
@ -520,7 +520,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
LIBSSH2_DISCONNECT(session, reason, message, LIBSSH2_DISCONNECT(session, reason, message,
message_len, language, language_len); message_len, language, language_len);
} }
_libssh2_debug(session, LIBSSH2_DBG_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"Disconnect(%d): %s(%s)", reason, "Disconnect(%d): %s(%s)", reason,
message, language); message, language);
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
@ -583,7 +583,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
* _libssh2_debug will actually truncate this for us so * _libssh2_debug will actually truncate this for us so
* that it's not an inordinate about of data * that it's not an inordinate about of data
*/ */
_libssh2_debug(session, LIBSSH2_DBG_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"Debug Packet: %s", message); "Debug Packet: %s", message);
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
session->packAdd_state = libssh2_NB_state_idle; session->packAdd_state = libssh2_NB_state_idle;
@ -616,7 +616,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
stream_id = _libssh2_ntohu32(data + 5); stream_id = _libssh2_ntohu32(data + 5);
} }
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"%d bytes packet_add() for %lu/%lu/%lu", "%d bytes packet_add() for %lu/%lu/%lu",
(int) (datalen - session->packAdd_data_head), (int) (datalen - session->packAdd_data_head),
session->packAdd_channel->local.id, session->packAdd_channel->local.id,
@ -630,7 +630,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
/* Pretend we didn't receive this */ /* Pretend we didn't receive this */
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Ignoring extended data and refunding %d bytes", "Ignoring extended data and refunding %d bytes",
(int) (datalen - 13)); (int) (datalen - 13));
/* Adjust the window based on the block we just freed */ /* Adjust the window based on the block we just freed */
@ -713,7 +713,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
} }
_libssh2_debug(session, _libssh2_debug(session,
LIBSSH2_DBG_CONN, LIBSSH2_TRACE_CONN,
"EOF received for channel %lu/%lu", "EOF received for channel %lu/%lu",
session->packAdd_channel->local.id, session->packAdd_channel->local.id,
session->packAdd_channel->remote.id); session->packAdd_channel->remote.id);
@ -736,7 +736,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
if (session->packAdd_channel) { if (session->packAdd_channel) {
session->packAdd_channel->exit_status = session->packAdd_channel->exit_status =
_libssh2_ntohu32(data + 9 + sizeof("exit-status")); _libssh2_ntohu32(data + 9 + sizeof("exit-status"));
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Exit status %lu received for channel %lu/%lu", "Exit status %lu received for channel %lu/%lu",
session->packAdd_channel->exit_status, session->packAdd_channel->exit_status,
session->packAdd_channel->local.id, session->packAdd_channel->local.id,
@ -759,7 +759,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
session->packAdd_state = libssh2_NB_state_idle; session->packAdd_state = libssh2_NB_state_idle;
return 0; return 0;
} }
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Close received for channel %lu/%lu", "Close received for channel %lu/%lu",
session->packAdd_channel->local.id, session->packAdd_channel->local.id,
session->packAdd_channel->remote.id); session->packAdd_channel->remote.id);
@ -816,7 +816,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
if (session->packAdd_channel && bytestoadd) { if (session->packAdd_channel && bytestoadd) {
session->packAdd_channel->local.window_size += bytestoadd; session->packAdd_channel->local.window_size += bytestoadd;
} }
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Window adjust received for channel %lu/%lu, adding %lu bytes, new window_size=%lu", "Window adjust received for channel %lu/%lu, adding %lu bytes, new window_size=%lu",
session->packAdd_channel->local.id, session->packAdd_channel->local.id,
session->packAdd_channel->remote.id, session->packAdd_channel->remote.id,
@ -864,7 +864,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
* Well, it's already in the brigade, * Well, it's already in the brigade,
* let's just call back into ourselves * let's just call back into ourselves
*/ */
_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Renegotiating Keys"); _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Renegotiating Keys");
session->packAdd_state = libssh2_NB_state_sent2; session->packAdd_state = libssh2_NB_state_sent2;
} }
@ -915,7 +915,7 @@ _libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type,
{ {
LIBSSH2_PACKET *packet = _libssh2_list_first(&session->packets); LIBSSH2_PACKET *packet = _libssh2_list_first(&session->packets);
_libssh2_debug(session, LIBSSH2_DBG_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"Looking for packet of type: %d", (int) packet_type); "Looking for packet of type: %d", (int) packet_type);
while (packet) { while (packet) {
@ -1054,7 +1054,7 @@ _libssh2_packet_burn(LIBSSH2_SESSION * session,
return i; return i;
} }
_libssh2_debug(session, LIBSSH2_DBG_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"Blocking until packet becomes available to burn"); "Blocking until packet becomes available to burn");
*state = libssh2_NB_state_created; *state = libssh2_NB_state_created;
} }

16
src/publickey.c
View File

@ -353,7 +353,7 @@ libssh2_publickey_init(LIBSSH2_SESSION * session)
session->pkeyInit_pkey = NULL; session->pkeyInit_pkey = NULL;
session->pkeyInit_channel = NULL; session->pkeyInit_channel = NULL;
_libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
"Initializing publickey subsystem"); "Initializing publickey subsystem");
session->pkeyInit_state = libssh2_NB_state_allocated; session->pkeyInit_state = libssh2_NB_state_allocated;
@ -434,7 +434,7 @@ libssh2_publickey_init(LIBSSH2_SESSION * session)
_libssh2_htonu32(s, LIBSSH2_PUBLICKEY_VERSION); _libssh2_htonu32(s, LIBSSH2_PUBLICKEY_VERSION);
s += 4; s += 4;
_libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
"Sending publickey version packet advertising version %d support", "Sending publickey version packet advertising version %d support",
(int) LIBSSH2_PUBLICKEY_VERSION); (int) LIBSSH2_PUBLICKEY_VERSION);
@ -519,13 +519,13 @@ libssh2_publickey_init(LIBSSH2_SESSION * session)
session->pkeyInit_pkey->version = _libssh2_ntohu32(s); session->pkeyInit_pkey->version = _libssh2_ntohu32(s);
if (session->pkeyInit_pkey->version > if (session->pkeyInit_pkey->version >
LIBSSH2_PUBLICKEY_VERSION) { LIBSSH2_PUBLICKEY_VERSION) {
_libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
"Truncating remote publickey version from %lu", "Truncating remote publickey version from %lu",
session->pkeyInit_pkey->version); session->pkeyInit_pkey->version);
session->pkeyInit_pkey->version = session->pkeyInit_pkey->version =
LIBSSH2_PUBLICKEY_VERSION; LIBSSH2_PUBLICKEY_VERSION;
} }
_libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
"Enabling publickey subsystem version %lu", "Enabling publickey subsystem version %lu",
session->pkeyInit_pkey->version); session->pkeyInit_pkey->version);
LIBSSH2_FREE(session, session->pkeyInit_data); LIBSSH2_FREE(session, session->pkeyInit_data);
@ -590,7 +590,7 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY * pkey, const unsigned char *name,
if (pkey->add_state == libssh2_NB_state_idle) { if (pkey->add_state == libssh2_NB_state_idle) {
pkey->add_packet = NULL; pkey->add_packet = NULL;
_libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, "Adding %s publickey", _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY, "Adding %s publickey",
name); name);
if (pkey->version == 1) { if (pkey->version == 1) {
@ -671,7 +671,7 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY * pkey, const unsigned char *name,
} }
} }
_libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
"Sending publickey \"add\" packet: type=%s blob_len=%ld num_attrs=%ld", "Sending publickey \"add\" packet: type=%s blob_len=%ld num_attrs=%ld",
name, blob_len, num_attrs); name, blob_len, num_attrs);
@ -747,7 +747,7 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
memcpy(pkey->remove_s, blob, blob_len); memcpy(pkey->remove_s, blob, blob_len);
pkey->remove_s += blob_len; pkey->remove_s += blob_len;
_libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
"Sending publickey \"remove\" packet: type=%s blob_len=%ld", "Sending publickey \"remove\" packet: type=%s blob_len=%ld",
name, blob_len); name, blob_len);
@ -809,7 +809,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
memcpy(pkey->listFetch_s, "list", sizeof("list") - 1); memcpy(pkey->listFetch_s, "list", sizeof("list") - 1);
pkey->listFetch_s += sizeof("list") - 1; pkey->listFetch_s += sizeof("list") - 1;
_libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
"Sending publickey \"list\" packet"); "Sending publickey \"list\" packet");
pkey->listFetch_state = libssh2_NB_state_created; pkey->listFetch_state = libssh2_NB_state_created;

14
src/scp.c
View File

@ -301,7 +301,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb)
session->scpRecv_command_len - cmd_len); session->scpRecv_command_len - cmd_len);
_libssh2_debug(session, LIBSSH2_DBG_SCP, _libssh2_debug(session, LIBSSH2_TRACE_SCP,
"Opening channel for SCP receive"); "Opening channel for SCP receive");
session->scpRecv_state = libssh2_NB_state_created; session->scpRecv_state = libssh2_NB_state_created;
@ -350,7 +350,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb)
LIBSSH2_FREE(session, session->scpRecv_command); LIBSSH2_FREE(session, session->scpRecv_command);
session->scpRecv_command = NULL; session->scpRecv_command = NULL;
_libssh2_debug(session, LIBSSH2_DBG_SCP, "Sending initial wakeup"); _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sending initial wakeup");
/* SCP ACK */ /* SCP ACK */
session->scpRecv_response[0] = '\0'; session->scpRecv_response[0] = '\0';
@ -569,7 +569,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb)
goto scp_recv_error; goto scp_recv_error;
} }
_libssh2_debug(session, LIBSSH2_DBG_SCP, _libssh2_debug(session, LIBSSH2_TRACE_SCP,
"mtime = %ld, atime = %ld", "mtime = %ld, atime = %ld",
session->scpRecv_mtime, session->scpRecv_atime); session->scpRecv_mtime, session->scpRecv_atime);
@ -731,7 +731,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb)
} else if (rc != 1) { } else if (rc != 1) {
goto scp_recv_error; goto scp_recv_error;
} }
_libssh2_debug(session, LIBSSH2_DBG_SCP, _libssh2_debug(session, LIBSSH2_TRACE_SCP,
"mode = 0%lo size = %ld", session->scpRecv_mode, "mode = 0%lo size = %ld", session->scpRecv_mode,
session->scpRecv_size); session->scpRecv_size);
@ -816,7 +816,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
session->scpSend_command[session->scpSend_command_len - 1] = '\0'; session->scpSend_command[session->scpSend_command_len - 1] = '\0';
_libssh2_debug(session, LIBSSH2_DBG_SCP, _libssh2_debug(session, LIBSSH2_TRACE_SCP,
"Opening channel for SCP send"); "Opening channel for SCP send");
/* Allocate a channel */ /* Allocate a channel */
@ -892,7 +892,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
snprintf((char *) session->scpSend_response, snprintf((char *) session->scpSend_response,
LIBSSH2_SCP_RESPONSE_BUFLEN, "T%ld 0 %ld 0\n", mtime, LIBSSH2_SCP_RESPONSE_BUFLEN, "T%ld 0 %ld 0\n", mtime,
atime); atime);
_libssh2_debug(session, LIBSSH2_DBG_SCP, "Sent %s", _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sent %s",
session->scpSend_response); session->scpSend_response);
} }
@ -953,7 +953,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
snprintf((char *) session->scpSend_response, snprintf((char *) session->scpSend_response,
LIBSSH2_SCP_RESPONSE_BUFLEN, "C0%o %lu %s\n", mode, LIBSSH2_SCP_RESPONSE_BUFLEN, "C0%o %lu %s\n", mode,
(unsigned long) size, base); (unsigned long) size, base);
_libssh2_debug(session, LIBSSH2_DBG_SCP, "Sent %s", _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sent %s",
session->scpSend_response); session->scpSend_response);
session->scpSend_state = libssh2_NB_state_sent5; session->scpSend_state = libssh2_NB_state_sent5;

28
src/session.c
View File

@ -112,10 +112,10 @@ banner_receive(LIBSSH2_SESSION * session)
ret = _libssh2_recv(session->socket_fd, &c, 1, ret = _libssh2_recv(session->socket_fd, &c, 1,
LIBSSH2_SOCKET_RECV_FLAGS(session)); LIBSSH2_SOCKET_RECV_FLAGS(session));
if (ret < 0) if (ret < 0)
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Error recving %d bytes to %p: %d", 1, &c, errno); "Error recving %d bytes to %p: %d", 1, &c, errno);
else else
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Recved %d bytes to %p", ret, &c); "Recved %d bytes to %p", ret, &c);
if (ret < 0) { if (ret < 0) {
@ -168,7 +168,7 @@ banner_receive(LIBSSH2_SESSION * session)
} }
memcpy(session->remote.banner, session->banner_TxRx_banner, banner_len); memcpy(session->remote.banner, session->banner_TxRx_banner, banner_len);
session->remote.banner[banner_len] = '\0'; session->remote.banner[banner_len] = '\0';
_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Received Banner: %s", _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Received Banner: %s",
session->remote.banner); session->remote.banner);
return 0; return 0;
} }
@ -209,7 +209,7 @@ banner_send(LIBSSH2_SESSION * session)
banner[255] = '\0'; banner[255] = '\0';
} }
_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Sending Banner: %s", _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Sending Banner: %s",
banner_dup); banner_dup);
#endif #endif
@ -224,11 +224,11 @@ banner_send(LIBSSH2_SESSION * session)
banner_len - session->banner_TxRx_total_send, banner_len - session->banner_TxRx_total_send,
LIBSSH2_SOCKET_SEND_FLAGS(session)); LIBSSH2_SOCKET_SEND_FLAGS(session));
if (ret < 0) if (ret < 0)
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Error sending %d bytes: %d", "Error sending %d bytes: %d",
banner_len - session->banner_TxRx_total_send, errno); banner_len - session->banner_TxRx_total_send, errno);
else else
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Sent %d/%d bytes at %p+%d", ret, "Sent %d/%d bytes at %p+%d", ret,
banner_len - session->banner_TxRx_total_send, banner_len - session->banner_TxRx_total_send,
banner, session->banner_TxRx_total_send); banner, session->banner_TxRx_total_send);
@ -410,7 +410,7 @@ libssh2_banner_set(LIBSSH2_SESSION * session, const char *banner)
memcpy(session->local.banner, banner, banner_len); memcpy(session->local.banner, banner, banner_len);
session->local.banner[banner_len] = '\0'; session->local.banner[banner_len] = '\0';
_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Setting local Banner: %s", _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Setting local Banner: %s",
session->local.banner); session->local.banner);
session->local.banner[banner_len++] = '\r'; session->local.banner[banner_len++] = '\r';
session->local.banner[banner_len++] = '\n'; session->local.banner[banner_len++] = '\n';
@ -456,7 +456,7 @@ libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)),
session->realloc = local_realloc; session->realloc = local_realloc;
session->abstract = abstract; session->abstract = abstract;
session->api_block_mode = 1; /* blocking API by default */ session->api_block_mode = 1; /* blocking API by default */
_libssh2_debug(session, LIBSSH2_DBG_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"New session resource allocated"); "New session resource allocated");
libssh2_crypto_init(); libssh2_crypto_init();
} }
@ -505,7 +505,7 @@ libssh2_session_callback_set(LIBSSH2_SESSION * session,
return oldcb; return oldcb;
} }
_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Setting Callback %d", cbtype); _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Setting Callback %d", cbtype);
return NULL; return NULL;
} }
@ -555,7 +555,7 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
int rc; int rc;
if (session->startup_state == libssh2_NB_state_idle) { if (session->startup_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"session_startup for socket %d", sock); "session_startup for socket %d", sock);
/* FIXME: on some platforms (like win32) sockets are unsigned */ /* FIXME: on some platforms (like win32) sockets are unsigned */
if (sock < 0) { if (sock < 0) {
@ -610,7 +610,7 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
} }
if (session->startup_state == libssh2_NB_state_sent2) { if (session->startup_state == libssh2_NB_state_sent2) {
_libssh2_debug(session, LIBSSH2_DBG_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"Requesting userauth service"); "Requesting userauth service");
/* Request the userauth service */ /* Request the userauth service */
@ -701,7 +701,7 @@ session_free(LIBSSH2_SESSION *session)
LIBSSH2_LISTENER *l; LIBSSH2_LISTENER *l;
if (session->free_state == libssh2_NB_state_idle) { if (session->free_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Freeing session resource", _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Freeing session resource",
session->remote.banner); session->remote.banner);
session->state = libssh2_NB_state_created; session->state = libssh2_NB_state_created;
@ -961,7 +961,7 @@ session_disconnect(LIBSSH2_SESSION *session, int reason,
int rc; int rc;
if (session->disconnect_state == libssh2_NB_state_idle) { if (session->disconnect_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"Disconnecting: reason=%d, desc=%s, lang=%s", reason, "Disconnecting: reason=%d, desc=%s, lang=%s", reason,
description, lang); description, lang);
if (description) { if (description) {
@ -1207,7 +1207,7 @@ int
_libssh2_session_set_blocking(LIBSSH2_SESSION *session, int blocking) _libssh2_session_set_blocking(LIBSSH2_SESSION *session, int blocking)
{ {
int bl = session->api_block_mode; int bl = session->api_block_mode;
_libssh2_debug(session, LIBSSH2_DBG_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Setting blocking mode %s", blocking?"ON":"OFF"); "Setting blocking mode %s", blocking?"ON":"OFF");
session->api_block_mode = blocking; session->api_block_mode = blocking;

64
src/sftp.c
View File

@ -118,7 +118,7 @@ sftp_packet_add(LIBSSH2_SFTP *sftp, unsigned char *data,
LIBSSH2_SESSION *session = sftp->channel->session; LIBSSH2_SESSION *session = sftp->channel->session;
LIBSSH2_PACKET *packet; LIBSSH2_PACKET *packet;
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Received packet %d (len %d)", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Received packet %d (len %d)",
(int) data[0], data_len); (int) data[0], data_len);
packet = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET)); packet = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET));
if (!packet) { if (!packet) {
@ -153,7 +153,7 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
ssize_t bytes_received; ssize_t bytes_received;
int rc; int rc;
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "recv packet"); _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "recv packet");
/* If there was a previous partial, start using it */ /* If there was a previous partial, start using it */
if (sftp->partial_packet) { if (sftp->partial_packet) {
@ -163,7 +163,7 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
packet_received = sftp->partial_received; packet_received = sftp->partial_received;
sftp->partial_packet = NULL; sftp->partial_packet = NULL;
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"partial read cont, len: %lu", packet_len); "partial read cont, len: %lu", packet_len);
} }
else { else {
@ -181,7 +181,7 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
} }
packet_len = _libssh2_ntohu32(buffer); packet_len = _libssh2_ntohu32(buffer);
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"Data begin - Packet Length: %lu", packet_len); "Data begin - Packet Length: %lu", packet_len);
if (packet_len > LIBSSH2_SFTP_PACKET_MAXLEN) { if (packet_len > LIBSSH2_SFTP_PACKET_MAXLEN) {
libssh2_error(session, LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED, libssh2_error(session, LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED,
@ -251,7 +251,7 @@ sftp_packet_ask(LIBSSH2_SFTP *sftp, unsigned char packet_type,
unsigned char match_buf[5]; unsigned char match_buf[5];
int match_len; int match_len;
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Asking for %d packet", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Asking for %d packet",
(int) packet_type); (int) packet_type);
match_buf[0] = packet_type; match_buf[0] = packet_type;
@ -293,12 +293,12 @@ sftp_packet_require(LIBSSH2_SFTP *sftp, unsigned char packet_type,
LIBSSH2_SESSION *session = sftp->channel->session; LIBSSH2_SESSION *session = sftp->channel->session;
int ret; int ret;
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Requiring packet %d id %ld", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Requiring packet %d id %ld",
(int) packet_type, request_id); (int) packet_type, request_id);
if (sftp_packet_ask(sftp, packet_type, request_id, data, data_len) == 0) { if (sftp_packet_ask(sftp, packet_type, request_id, data, data_len) == 0) {
/* The right packet was available in the packet brigade */ /* The right packet was available in the packet brigade */
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Got %d", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Got %d",
(int) packet_type); (int) packet_type);
return 0; return 0;
} }
@ -314,7 +314,7 @@ sftp_packet_require(LIBSSH2_SFTP *sftp, unsigned char packet_type,
/* data was read, check the queue again */ /* data was read, check the queue again */
if (!sftp_packet_ask(sftp, packet_type, request_id, data, data_len)) { if (!sftp_packet_ask(sftp, packet_type, request_id, data, data_len)) {
/* The right packet was available in the packet brigade */ /* The right packet was available in the packet brigade */
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Got %d", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Got %d",
(int) packet_type); (int) packet_type);
return 0; return 0;
} }
@ -530,7 +530,7 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
LIBSSH2_SFTP *sftp_handle; LIBSSH2_SFTP *sftp_handle;
if (session->sftpInit_state == libssh2_NB_state_idle) { if (session->sftpInit_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"Initializing SFTP subsystem"); "Initializing SFTP subsystem");
/* /*
@ -616,7 +616,7 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
session->sftpInit_buffer[4] = SSH_FXP_INIT; session->sftpInit_buffer[4] = SSH_FXP_INIT;
_libssh2_htonu32(session->sftpInit_buffer + 5, LIBSSH2_SFTP_VERSION); _libssh2_htonu32(session->sftpInit_buffer + 5, LIBSSH2_SFTP_VERSION);
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"Sending FXP_INIT packet advertising version %d support", "Sending FXP_INIT packet advertising version %d support",
(int) LIBSSH2_SFTP_VERSION); (int) LIBSSH2_SFTP_VERSION);
@ -661,12 +661,12 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
sftp_handle->version = _libssh2_ntohu32(s); sftp_handle->version = _libssh2_ntohu32(s);
s += 4; s += 4;
if (sftp_handle->version > LIBSSH2_SFTP_VERSION) { if (sftp_handle->version > LIBSSH2_SFTP_VERSION) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"Truncating remote SFTP version from %lu", "Truncating remote SFTP version from %lu",
sftp_handle->version); sftp_handle->version);
sftp_handle->version = LIBSSH2_SFTP_VERSION; sftp_handle->version = LIBSSH2_SFTP_VERSION;
} }
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"Enabling SFTP version %lu compatability", "Enabling SFTP version %lu compatability",
sftp_handle->version); sftp_handle->version);
while (s < (data + data_len)) { while (s < (data + data_len)) {
@ -864,7 +864,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
s += sftp_attr2bin(s, &attrs); s += sftp_attr2bin(s, &attrs);
} }
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Sending %s open request", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Sending %s open request",
(open_type == (open_type ==
LIBSSH2_SFTP_OPENFILE) ? "file" : "directory"); LIBSSH2_SFTP_OPENFILE) ? "file" : "directory");
@ -925,7 +925,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
sftp->last_errno = _libssh2_ntohu32(data + 5); sftp->last_errno = _libssh2_ntohu32(data + 5);
if(LIBSSH2_FX_OK == sftp->last_errno) { if(LIBSSH2_FX_OK == sftp->last_errno) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "got HANDLE FXOK!"); _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "got HANDLE FXOK!");
/* silly situation, but check for a HANDLE */ /* silly situation, but check for a HANDLE */
rc = sftp_packet_require(sftp, SSH_FXP_HANDLE, rc = sftp_packet_require(sftp, SSH_FXP_HANDLE,
@ -943,7 +943,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
if(badness) { if(badness) {
libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
"Failed opening remote file", 0); "Failed opening remote file", 0);
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "got FXP_STATUS %d", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "got FXP_STATUS %d",
sftp->last_errno); sftp->last_errno);
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
return NULL; return NULL;
@ -979,7 +979,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
fp->u.file.offset = 0; fp->u.file.offset = 0;
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Open command successful"); _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Open command successful");
return fp; return fp;
} }
@ -1019,7 +1019,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
int retcode; int retcode;
if (sftp->read_state == libssh2_NB_state_idle) { if (sftp->read_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"Reading %lu bytes from SFTP handle", "Reading %lu bytes from SFTP handle",
(unsigned long) buffer_maxlen); (unsigned long) buffer_maxlen);
packet = handle->request_packet; packet = handle->request_packet;
@ -1057,7 +1057,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
bytes_requested = LIBSSH2_SFTP_PACKET_MAXLEN - 13; bytes_requested = LIBSSH2_SFTP_PACKET_MAXLEN - 13;
} }
#ifdef LIBSSH2_DEBUG_SFTP #ifdef LIBSSH2_DEBUG_SFTP
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"Requesting %lu bytes from SFTP handle", "Requesting %lu bytes from SFTP handle",
(unsigned long) bytes_requested); (unsigned long) bytes_requested);
#endif #endif
@ -1153,7 +1153,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
return -1; return -1;
} }
#ifdef LIBSSH2_DEBUG_SFTP #ifdef LIBSSH2_DEBUG_SFTP
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "%lu bytes returned", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%lu bytes returned",
(unsigned long) bytes_read); (unsigned long) bytes_read);
#endif #endif
memcpy(buffer + total_read, data + 9, bytes_read); memcpy(buffer + total_read, data + 9, bytes_read);
@ -1257,7 +1257,7 @@ static int sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
LIBSSH2_FREE(session, handle->u.dir.names_packet); LIBSSH2_FREE(session, handle->u.dir.names_packet);
} }
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"libssh2_sftp_readdir_ex() return %d", "libssh2_sftp_readdir_ex() return %d",
filename_len); filename_len);
return filename_len; return filename_len;
@ -1288,7 +1288,7 @@ static int sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
} }
if (sftp->readdir_state == libssh2_NB_state_created) { if (sftp->readdir_state == libssh2_NB_state_created) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"Reading entries from directory handle"); "Reading entries from directory handle");
retcode = _libssh2_channel_write(channel, 0, retcode = _libssh2_channel_write(channel, 0,
(char *) sftp->readdir_packet, (char *) sftp->readdir_packet,
@ -1340,7 +1340,7 @@ static int sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
} }
num_names = _libssh2_ntohu32(data + 5); num_names = _libssh2_ntohu32(data + 5);
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "%lu entries returned", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%lu entries returned",
num_names); num_names);
if (num_names <= 0) { if (num_names <= 0) {
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
@ -1431,7 +1431,7 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
packet_len = handle->handle_len + count + 25; packet_len = handle->handle_len + count + 25;
if (sftp->write_state == libssh2_NB_state_idle) { if (sftp->write_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Writing %lu bytes", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Writing %lu bytes",
(unsigned long) count); (unsigned long) count);
s = sftp->write_packet = LIBSSH2_ALLOC(session, packet_len); s = sftp->write_packet = LIBSSH2_ALLOC(session, packet_len);
if (!sftp->write_packet) { if (!sftp->write_packet) {
@ -1541,7 +1541,7 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
int rc; int rc;
if (sftp->fstat_state == libssh2_NB_state_idle) { if (sftp->fstat_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Issuing %s command", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Issuing %s command",
setstat ? "set-stat" : "stat"); setstat ? "set-stat" : "stat");
s = sftp->fstat_packet = LIBSSH2_ALLOC(session, packet_len); s = sftp->fstat_packet = LIBSSH2_ALLOC(session, packet_len);
if (!sftp->fstat_packet) { if (!sftp->fstat_packet) {
@ -1693,7 +1693,7 @@ sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
int rc; int rc;
if (handle->close_state == libssh2_NB_state_idle) { if (handle->close_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Closing handle"); _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Closing handle");
s = handle->close_packet = LIBSSH2_ALLOC(session, packet_len); s = handle->close_packet = LIBSSH2_ALLOC(session, packet_len);
if (!handle->close_packet) { if (!handle->close_packet) {
libssh2_error(session, LIBSSH2_ERROR_ALLOC, libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@ -1804,7 +1804,7 @@ static int sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename,
int rc; int rc;
if (sftp->unlink_state == libssh2_NB_state_idle) { if (sftp->unlink_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Unlinking %s", filename); _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Unlinking %s", filename);
s = sftp->unlink_packet = LIBSSH2_ALLOC(session, packet_len); s = sftp->unlink_packet = LIBSSH2_ALLOC(session, packet_len);
if (!sftp->unlink_packet) { if (!sftp->unlink_packet) {
libssh2_error(session, LIBSSH2_ERROR_ALLOC, libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@ -1916,7 +1916,7 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
} }
if (sftp->rename_state == libssh2_NB_state_idle) { if (sftp->rename_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Renaming %s to %s", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Renaming %s to %s",
source_filename, dest_filename); source_filename, dest_filename);
sftp->rename_s = sftp->rename_packet = sftp->rename_s = sftp->rename_packet =
LIBSSH2_ALLOC(session, packet_len); LIBSSH2_ALLOC(session, packet_len);
@ -2052,7 +2052,7 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
int rc; int rc;
if (sftp->mkdir_state == libssh2_NB_state_idle) { if (sftp->mkdir_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
"Creating directory %s with mode 0%lo", path, mode); "Creating directory %s with mode 0%lo", path, mode);
s = packet = LIBSSH2_ALLOC(session, packet_len); s = packet = LIBSSH2_ALLOC(session, packet_len);
if (!packet) { if (!packet) {
@ -2116,7 +2116,7 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
if (retcode == LIBSSH2_FX_OK) { if (retcode == LIBSSH2_FX_OK) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "OK!"); _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "OK!");
return 0; return 0;
} else { } else {
libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
@ -2156,7 +2156,7 @@ static int sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path,
int rc; int rc;
if (sftp->rmdir_state == libssh2_NB_state_idle) { if (sftp->rmdir_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Removing directory: %s", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Removing directory: %s",
path); path);
s = sftp->rmdir_packet = LIBSSH2_ALLOC(session, packet_len); s = sftp->rmdir_packet = LIBSSH2_ALLOC(session, packet_len);
if (!sftp->rmdir_packet) { if (!sftp->rmdir_packet) {
@ -2258,7 +2258,7 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
int rc; int rc;
if (sftp->stat_state == libssh2_NB_state_idle) { if (sftp->stat_state == libssh2_NB_state_idle) {
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "%s %s", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%s %s",
(stat_type == LIBSSH2_SFTP_SETSTAT) ? "Set-statting" : (stat_type == LIBSSH2_SFTP_SETSTAT) ? "Set-statting" :
(stat_type == (stat_type ==
LIBSSH2_SFTP_LSTAT ? "LStatting" : "Statting"), path); LIBSSH2_SFTP_LSTAT ? "LStatting" : "Statting"), path);
@ -2400,7 +2400,7 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
return -1; return -1;
} }
_libssh2_debug(session, LIBSSH2_DBG_SFTP, "%s %s on %s", _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%s %s on %s",
(link_type == (link_type ==
LIBSSH2_SFTP_SYMLINK) ? "Creating" : "Reading", LIBSSH2_SFTP_SYMLINK) ? "Creating" : "Reading",
(link_type == (link_type ==

16
src/transport.c
View File

@ -60,7 +60,7 @@ debugdump(LIBSSH2_SESSION * session,
FILE *stream = stderr; FILE *stream = stderr;
unsigned int width = 0x10; unsigned int width = 0x10;
if (!(session->showmask & (1 << LIBSSH2_DBG_TRANS))) { if (!(session->showmask & LIBSSH2_TRACE_TRANS)) {
/* not asked for, bail out */ /* not asked for, bail out */
return; return;
} }
@ -290,7 +290,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
/* Whoever wants a packet won't get anything until the key re-exchange /* Whoever wants a packet won't get anything until the key re-exchange
* is done! * is done!
*/ */
_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Redirecting into the" _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
" key re-exchange"); " key re-exchange");
rc = libssh2_kex_exchange(session, 1, &session->startup_key_state); rc = libssh2_kex_exchange(session, 1, &session->startup_key_state);
if (rc) if (rc)
@ -356,12 +356,12 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
PACKETBUFSIZE - remainbuf, PACKETBUFSIZE - remainbuf,
LIBSSH2_SOCKET_RECV_FLAGS(session)); LIBSSH2_SOCKET_RECV_FLAGS(session));
if (nread < 0) if (nread < 0)
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Error recving %d bytes to %p+%d: %d", "Error recving %d bytes to %p+%d: %d",
PACKETBUFSIZE - remainbuf, p->buf, remainbuf, PACKETBUFSIZE - remainbuf, p->buf, remainbuf,
errno); errno);
else else
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Recved %d/%d bytes to %p+%d", nread, "Recved %d/%d bytes to %p+%d", nread,
PACKETBUFSIZE - remainbuf, p->buf, remainbuf); PACKETBUFSIZE - remainbuf, p->buf, remainbuf);
if (nread <= 0) { if (nread <= 0) {
@ -612,10 +612,10 @@ send_existing(LIBSSH2_SESSION * session, unsigned char *data,
rc = _libssh2_send(session->socket_fd, &p->outbuf[p->osent], length, rc = _libssh2_send(session->socket_fd, &p->outbuf[p->osent], length,
LIBSSH2_SOCKET_SEND_FLAGS(session)); LIBSSH2_SOCKET_SEND_FLAGS(session));
if (rc < 0) if (rc < 0)
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Error sending %d bytes: %d", length, errno); "Error sending %d bytes: %d", length, errno);
else else
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Sent %d/%d bytes at %p+%d", rc, length, p->outbuf, "Sent %d/%d bytes at %p+%d", rc, length, p->outbuf,
p->osent); p->osent);
@ -793,10 +793,10 @@ _libssh2_transport_write(LIBSSH2_SESSION * session, unsigned char *data,
ret = _libssh2_send(session->socket_fd, p->outbuf, total_length, ret = _libssh2_send(session->socket_fd, p->outbuf, total_length,
LIBSSH2_SOCKET_SEND_FLAGS(session)); LIBSSH2_SOCKET_SEND_FLAGS(session));
if (ret < 0) if (ret < 0)
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Error sending %d bytes: %d", total_length, errno); "Error sending %d bytes: %d", total_length, errno);
else else
_libssh2_debug(session, LIBSSH2_DBG_SOCKET, "Sent %d/%d bytes at %p", _libssh2_debug(session, LIBSSH2_TRACE_SOCKET, "Sent %d/%d bytes at %p",
ret, total_length, p->outbuf); ret, total_length, p->outbuf);
if (ret != -1) { if (ret != -1) {

30
src/userauth.c
View File

@ -155,7 +155,7 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
memmove(session->userauth_list_data, session->userauth_list_data + 5, memmove(session->userauth_list_data, session->userauth_list_data + 5,
methods_len); methods_len);
session->userauth_list_data[methods_len] = '\0'; session->userauth_list_data[methods_len] = '\0';
_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Permitted auth methods: %s", _libssh2_debug(session, LIBSSH2_TRACE_AUTH, "Permitted auth methods: %s",
session->userauth_list_data); session->userauth_list_data);
} }
@ -256,7 +256,7 @@ userauth_password(LIBSSH2_SESSION *session, const char *username,
memcpy(s, password, password_len); memcpy(s, password, password_len);
s += password_len; s += password_len;
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Attempting to login using password authentication"); "Attempting to login using password authentication");
session->userauth_pswd_state = libssh2_NB_state_created; session->userauth_pswd_state = libssh2_NB_state_created;
@ -301,7 +301,7 @@ userauth_password(LIBSSH2_SESSION *session, const char *username,
} }
if (session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if (session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Password authentication successful"); "Password authentication successful");
LIBSSH2_FREE(session, session->userauth_pswd_data); LIBSSH2_FREE(session, session->userauth_pswd_data);
session->userauth_pswd_data = NULL; session->userauth_pswd_data = NULL;
@ -325,7 +325,7 @@ userauth_password(LIBSSH2_SESSION *session, const char *username,
if ((session->userauth_pswd_state == libssh2_NB_state_sent1) || if ((session->userauth_pswd_state == libssh2_NB_state_sent1) ||
(session->userauth_pswd_state == libssh2_NB_state_sent2)) { (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
if (session->userauth_pswd_state == libssh2_NB_state_sent1) { if (session->userauth_pswd_state == libssh2_NB_state_sent1) {
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Password change required"); "Password change required");
LIBSSH2_FREE(session, session->userauth_pswd_data); LIBSSH2_FREE(session, session->userauth_pswd_data);
session->userauth_pswd_data = NULL; session->userauth_pswd_data = NULL;
@ -484,7 +484,7 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
size_t pubkey_len = 0; size_t pubkey_len = 0;
unsigned int tmp_len; unsigned int tmp_len;
_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Loading public key file: %s", _libssh2_debug(session, LIBSSH2_TRACE_AUTH, "Loading public key file: %s",
pubkeyfile); pubkeyfile);
/* Read Public Key */ /* Read Public Key */
fd = fopen(pubkeyfile, "r"); fd = fopen(pubkeyfile, "r");
@ -583,7 +583,7 @@ file_read_privatekey(LIBSSH2_SESSION * session,
const LIBSSH2_HOSTKEY_METHOD **hostkey_methods_avail = const LIBSSH2_HOSTKEY_METHOD **hostkey_methods_avail =
libssh2_hostkey_methods(); libssh2_hostkey_methods();
_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Loading private key file: %s", _libssh2_debug(session, LIBSSH2_TRACE_AUTH, "Loading private key file: %s",
privkeyfile); privkeyfile);
*hostkey_method = NULL; *hostkey_method = NULL;
*hostkey_abstract = NULL; *hostkey_abstract = NULL;
@ -795,7 +795,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
session->userauth_host_s += sig_len; session->userauth_host_s += sig_len;
LIBSSH2_FREE(session, sig); LIBSSH2_FREE(session, sig);
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Attempting hostbased authentication"); "Attempting hostbased authentication");
session->userauth_host_state = libssh2_NB_state_created; session->userauth_host_state = libssh2_NB_state_created;
@ -839,7 +839,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
return -1; return -1;
if (session->userauth_host_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if (session->userauth_host_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Hostbased authentication successful"); "Hostbased authentication successful");
/* We are us and we've proved it. */ /* We are us and we've proved it. */
LIBSSH2_FREE(session, session->userauth_host_data); LIBSSH2_FREE(session, session->userauth_host_data);
@ -977,7 +977,7 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session,
session->userauth_pblc_s += pubkeydata_len; session->userauth_pblc_s += pubkeydata_len;
LIBSSH2_FREE(session, pubkeydata); LIBSSH2_FREE(session, pubkeydata);
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Attempting publickey authentication"); "Attempting publickey authentication");
session->userauth_pblc_state = libssh2_NB_state_created; session->userauth_pblc_state = libssh2_NB_state_created;
@ -1028,7 +1028,7 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session,
} }
if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Pubkey authentication prematurely successful"); "Pubkey authentication prematurely successful");
/* /*
* God help any SSH server that allows an UNVERIFIED * God help any SSH server that allows an UNVERIFIED
@ -1152,7 +1152,7 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session,
session->userauth_pblc_s += sig_len; session->userauth_pblc_s += sig_len;
LIBSSH2_FREE(session, sig); LIBSSH2_FREE(session, sig);
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Attempting publickey authentication -- phase 2"); "Attempting publickey authentication -- phase 2");
session->userauth_pblc_state = libssh2_NB_state_sent1; session->userauth_pblc_state = libssh2_NB_state_sent1;
@ -1193,7 +1193,7 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session,
} }
if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Publickey authentication successful"); "Publickey authentication successful");
/* We are us and we've proved it. */ /* We are us and we've proved it. */
LIBSSH2_FREE(session, session->userauth_pblc_data); LIBSSH2_FREE(session, session->userauth_pblc_data);
@ -1317,7 +1317,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
_libssh2_htonu32(s, 0); _libssh2_htonu32(s, 0);
s += 4; s += 4;
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Attempting keyboard-interactive authentication"); "Attempting keyboard-interactive authentication");
session->userauth_kybd_state = libssh2_NB_state_created; session->userauth_kybd_state = libssh2_NB_state_created;
@ -1358,7 +1358,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
} }
if (session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if (session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Keyboard-interactive authentication successful"); "Keyboard-interactive authentication successful");
LIBSSH2_FREE(session, session->userauth_kybd_data); LIBSSH2_FREE(session, session->userauth_kybd_data);
session->userauth_kybd_data = NULL; session->userauth_kybd_data = NULL;
@ -1483,7 +1483,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
session->userauth_kybd_responses, session->userauth_kybd_responses,
&session->abstract); &session->abstract);
_libssh2_debug(session, LIBSSH2_DBG_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Keyboard-interactive response callback function" "Keyboard-interactive response callback function"
" invoked"); " invoked");