diff --git a/src/channel.c b/src/channel.c index 6b4df98..bdbaeec 100644 --- a/src/channel.c +++ b/src/channel.c @@ -47,11 +47,13 @@ #endif -/* {{{ libssh2_channel_nextid +/* + * _libssh2_channel_nextid + * * Determine the next channel ID we can use at our end */ unsigned long -libssh2_channel_nextid(LIBSSH2_SESSION * session) +_libssh2_channel_nextid(LIBSSH2_SESSION * session) { unsigned long id = session->next_channel; LIBSSH2_CHANNEL *channel; @@ -78,13 +80,13 @@ libssh2_channel_nextid(LIBSSH2_SESSION * session) return id; } -/* }}} */ - -/* {{{ libssh2_channel_locate +/* + * _libssh2_channel_locate + * * Locate a channel pointer by number */ LIBSSH2_CHANNEL * -libssh2_channel_locate(LIBSSH2_SESSION * session, unsigned long channel_id) +_libssh2_channel_locate(LIBSSH2_SESSION * session, unsigned long channel_id) { LIBSSH2_CHANNEL *channel = session->channels.head; while (channel) { @@ -97,8 +99,6 @@ libssh2_channel_locate(LIBSSH2_SESSION * session, unsigned long channel_id) return NULL; } -/* }}} */ - #define CHANNEL_ADD(session, channel) \ { \ if ((session)->channels.tail) { \ @@ -113,7 +113,9 @@ libssh2_channel_locate(LIBSSH2_SESSION * session, unsigned long channel_id) (channel)->session = (session); \ } -/* {{{ libssh2_channel_open_ex +/* + * libssh2_channel_open_ex + * * Establish a generic session channel */ LIBSSH2_API LIBSSH2_CHANNEL * @@ -137,7 +139,7 @@ libssh2_channel_open_ex(LIBSSH2_SESSION * session, const char *channel_type, /* 17 = packet_type(1) + channel_type_len(4) + sender_channel(4) + * window_size(4) + packet_size(4) */ session->open_packet_len = channel_type_len + message_len + 17; - session->open_local_channel = libssh2_channel_nextid(session); + session->open_local_channel = _libssh2_channel_nextid(session); /* Zero the whole thing out */ memset(&session->open_packet_requirev_state, 0, @@ -184,19 +186,19 @@ libssh2_channel_open_ex(LIBSSH2_SESSION * session, const char *channel_type, goto channel_error; } *(s++) = SSH_MSG_CHANNEL_OPEN; - libssh2_htonu32(s, channel_type_len); + _libssh2_htonu32(s, channel_type_len); s += 4; memcpy(s, channel_type, channel_type_len); s += channel_type_len; - libssh2_htonu32(s, session->open_local_channel); + _libssh2_htonu32(s, session->open_local_channel); s += 4; - libssh2_htonu32(s, window_size); + _libssh2_htonu32(s, window_size); s += 4; - libssh2_htonu32(s, packet_size); + _libssh2_htonu32(s, packet_size); s += 4; if (message && message_len) { @@ -208,7 +210,7 @@ libssh2_channel_open_ex(LIBSSH2_SESSION * session, const char *channel_type, } if (session->open_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, session->open_packet, + rc = _libssh2_packet_write(session, session->open_packet, session->open_packet_len); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, @@ -224,12 +226,12 @@ libssh2_channel_open_ex(LIBSSH2_SESSION * session, const char *channel_type, } if (session->open_state == libssh2_NB_state_sent) { - rc = libssh2_packet_requirev(session, reply_codes, - &session->open_data, - &session->open_data_len, 1, - session->open_packet + 5 + - channel_type_len, 4, - &session->open_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, + &session->open_data, + &session->open_data_len, 1, + session->open_packet + 5 + + channel_type_len, 4, + &session->open_packet_requirev_state); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block", 0); return NULL; @@ -239,13 +241,13 @@ libssh2_channel_open_ex(LIBSSH2_SESSION * session, const char *channel_type, if (session->open_data[0] == SSH_MSG_CHANNEL_OPEN_CONFIRMATION) { session->open_channel->remote.id = - libssh2_ntohu32(session->open_data + 5); + _libssh2_ntohu32(session->open_data + 5); session->open_channel->local.window_size = - libssh2_ntohu32(session->open_data + 9); + _libssh2_ntohu32(session->open_data + 9); session->open_channel->local.window_size_initial = - libssh2_ntohu32(session->open_data + 9); + _libssh2_ntohu32(session->open_data + 9); session->open_channel->local.packet_size = - libssh2_ntohu32(session->open_data + 13); + _libssh2_ntohu32(session->open_data + 13); _libssh2_debug(session, LIBSSH2_DBG_CONN, "Connection Established - ID: %lu/%lu win: %lu/%lu" " pack: %lu/%lu", @@ -298,16 +300,16 @@ libssh2_channel_open_ex(LIBSSH2_SESSION * session, const char *channel_type, } /* Clear out packets meant for this channel */ - libssh2_htonu32(channel_id, session->open_channel->local.id); - while ((libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA, - &session->open_data, - &session->open_data_len, 1, - channel_id, 4, 0) >= 0) + _libssh2_htonu32(channel_id, session->open_channel->local.id); + while ((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA, + &session->open_data, + &session->open_data_len, 1, + channel_id, 4, 0) >= 0) || - (libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA, - &session->open_data, - &session->open_data_len, 1, - channel_id, 4, 0) >= 0)) { + (_libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA, + &session->open_data, + &session->open_data_len, 1, + channel_id, 4, 0) >= 0)) { LIBSSH2_FREE(session, session->open_data); session->open_data = NULL; } @@ -326,9 +328,9 @@ libssh2_channel_open_ex(LIBSSH2_SESSION * session, const char *channel_type, return NULL; } -/* }}} */ - -/* {{{ libssh2_channel_direct_tcpip_ex +/* + * libssh2_channel_direct_tcpip_ex + * * Tunnel TCP/IP connect through the SSH session to direct host/port */ LIBSSH2_API LIBSSH2_CHANNEL * @@ -357,18 +359,18 @@ libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION * session, const char *host, 0); return NULL; } - libssh2_htonu32(s, session->direct_host_len); + _libssh2_htonu32(s, session->direct_host_len); s += 4; memcpy(s, host, session->direct_host_len); s += session->direct_host_len; - libssh2_htonu32(s, port); + _libssh2_htonu32(s, port); s += 4; - libssh2_htonu32(s, session->direct_shost_len); + _libssh2_htonu32(s, session->direct_shost_len); s += 4; memcpy(s, shost, session->direct_shost_len); s += session->direct_shost_len; - libssh2_htonu32(s, sport); + _libssh2_htonu32(s, sport); s += 4; } @@ -403,9 +405,9 @@ libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION * session, const char *host, return channel; } -/* }}} */ - -/* {{{ libssh2_channel_forward_listen_ex +/* + * libssh2_channel_forward_listen_ex + * * Bind a port on the remote host and listen for connections */ LIBSSH2_API LIBSSH2_LISTENER * @@ -443,25 +445,25 @@ libssh2_channel_forward_listen_ex(LIBSSH2_SESSION * session, const char *host, } *(s++) = SSH_MSG_GLOBAL_REQUEST; - libssh2_htonu32(s, sizeof("tcpip-forward") - 1); + _libssh2_htonu32(s, sizeof("tcpip-forward") - 1); s += 4; memcpy(s, "tcpip-forward", sizeof("tcpip-forward") - 1); s += sizeof("tcpip-forward") - 1; *(s++) = 0x01; /* want_reply */ - libssh2_htonu32(s, session->fwdLstn_host_len); + _libssh2_htonu32(s, session->fwdLstn_host_len); s += 4; memcpy(s, host ? host : "0.0.0.0", session->fwdLstn_host_len); s += session->fwdLstn_host_len; - libssh2_htonu32(s, port); + _libssh2_htonu32(s, port); s += 4; session->fwdLstn_state = libssh2_NB_state_created; } if (session->fwdLstn_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, session->fwdLstn_packet, - session->fwdLstn_packet_len); + rc = _libssh2_packet_write(session, session->fwdLstn_packet, + session->fwdLstn_packet_len); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block sending global-request packet for " @@ -485,9 +487,9 @@ libssh2_channel_forward_listen_ex(LIBSSH2_SESSION * session, const char *host, } if (session->fwdLstn_state == libssh2_NB_state_sent) { - rc = libssh2_packet_requirev(session, reply_codes, &data, &data_len, - 0, NULL, 0, - &session->fwdLstn_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len, + 0, NULL, 0, + &session->fwdLstn_packet_requirev_state); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block", 0); return NULL; @@ -526,7 +528,7 @@ libssh2_channel_forward_listen_ex(LIBSSH2_SESSION * session, const char *host, session->fwdLstn_host_len); listener->host[session->fwdLstn_host_len] = 0; if (data_len >= 5 && !port) { - listener->port = libssh2_ntohu32(data + 1); + listener->port = _libssh2_ntohu32(data + 1); _libssh2_debug(session, LIBSSH2_DBG_CONN, "Dynamic tcpip-forward port allocated: %d", listener->port); @@ -567,9 +569,9 @@ libssh2_channel_forward_listen_ex(LIBSSH2_SESSION * session, const char *host, return NULL; } -/* }}} */ - -/* {{{ libssh2_channel_forward_cancel +/* + * libssh2_channel_forward_cancel + * * Stop listening on a remote port and free the listener * Toss out any pending (un-accept()ed) connections * @@ -601,17 +603,17 @@ libssh2_channel_forward_cancel(LIBSSH2_LISTENER * listener) } *(s++) = SSH_MSG_GLOBAL_REQUEST; - libssh2_htonu32(s, sizeof("cancel-tcpip-forward") - 1); + _libssh2_htonu32(s, sizeof("cancel-tcpip-forward") - 1); s += 4; memcpy(s, "cancel-tcpip-forward", sizeof("cancel-tcpip-forward") - 1); s += sizeof("cancel-tcpip-forward") - 1; *(s++) = 0x00; /* want_reply */ - libssh2_htonu32(s, host_len); + _libssh2_htonu32(s, host_len); s += 4; memcpy(s, listener->host, host_len); s += host_len; - libssh2_htonu32(s, listener->port); + _libssh2_htonu32(s, listener->port); s += 4; listener->chanFwdCncl_state = libssh2_NB_state_created; @@ -620,7 +622,7 @@ libssh2_channel_forward_cancel(LIBSSH2_LISTENER * listener) } if (listener->chanFwdCncl_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, packet, packet_len); + rc = _libssh2_packet_write(session, packet, packet_len); if (rc == PACKET_EAGAIN) { listener->chanFwdCncl_data = packet; } else if (rc) { @@ -664,9 +666,9 @@ libssh2_channel_forward_cancel(LIBSSH2_LISTENER * listener) return 0; } -/* }}} */ - -/* {{{ libssh2_channel_forward_accept +/* + * libssh2_channel_forward_accept + * * Accept a connection */ LIBSSH2_API LIBSSH2_CHANNEL * @@ -675,7 +677,7 @@ libssh2_channel_forward_accept(LIBSSH2_LISTENER * listener) libssh2pack_t rc; do { - rc = libssh2_packet_read(listener->session); + rc = _libssh2_packet_read(listener->session); if (rc == PACKET_EAGAIN) { libssh2_error(listener->session, LIBSSH2_ERROR_EAGAIN, "Would block waiting for packet", 0); @@ -711,9 +713,9 @@ libssh2_channel_forward_accept(LIBSSH2_LISTENER * listener) return NULL; } -/* }}} */ - -/* {{{ libssh2_channel_setenv_ex +/* + * libssh2_channel_setenv_ex + * * Set an environment variable prior to requesting a shell/program/subsystem */ LIBSSH2_API int @@ -751,21 +753,21 @@ libssh2_channel_setenv_ex(LIBSSH2_CHANNEL * channel, const char *varname, } *(s++) = SSH_MSG_CHANNEL_REQUEST; - libssh2_htonu32(s, channel->remote.id); + _libssh2_htonu32(s, channel->remote.id); s += 4; - libssh2_htonu32(s, sizeof("env") - 1); + _libssh2_htonu32(s, sizeof("env") - 1); s += 4; memcpy(s, "env", sizeof("env") - 1); s += sizeof("env") - 1; *(s++) = 0x01; - libssh2_htonu32(s, varname_len); + _libssh2_htonu32(s, varname_len); s += 4; memcpy(s, varname, varname_len); s += varname_len; - libssh2_htonu32(s, value_len); + _libssh2_htonu32(s, value_len); s += 4; memcpy(s, value, value_len); s += value_len; @@ -774,7 +776,7 @@ libssh2_channel_setenv_ex(LIBSSH2_CHANNEL * channel, const char *varname, } if (channel->setenv_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, channel->setenv_packet, + rc = _libssh2_packet_write(session, channel->setenv_packet, channel->setenv_packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; @@ -791,16 +793,16 @@ libssh2_channel_setenv_ex(LIBSSH2_CHANNEL * channel, const char *varname, LIBSSH2_FREE(session, channel->setenv_packet); channel->setenv_packet = NULL; - libssh2_htonu32(channel->setenv_local_channel, channel->local.id); + _libssh2_htonu32(channel->setenv_local_channel, channel->local.id); channel->setenv_state = libssh2_NB_state_sent; } if (channel->setenv_state == libssh2_NB_state_sent) { - rc = libssh2_packet_requirev(session, reply_codes, &data, &data_len, - 1, channel->setenv_local_channel, 4, - &channel-> - setenv_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len, + 1, channel->setenv_local_channel, 4, + &channel-> + setenv_packet_requirev_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } @@ -824,9 +826,8 @@ libssh2_channel_setenv_ex(LIBSSH2_CHANNEL * channel, const char *varname, return -1; } -/* }}} */ - -/* {{{ libssh2_channel_request_pty_ex +/* + * libssh2_channel_request_pty_ex * Duh... Request a PTY */ LIBSSH2_API int @@ -865,32 +866,32 @@ libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL * channel, const char *term, } *(s++) = SSH_MSG_CHANNEL_REQUEST; - libssh2_htonu32(s, channel->remote.id); + _libssh2_htonu32(s, channel->remote.id); s += 4; - libssh2_htonu32(s, sizeof("pty-req") - 1); + _libssh2_htonu32(s, sizeof("pty-req") - 1); s += 4; memcpy(s, "pty-req", sizeof("pty-req") - 1); s += sizeof("pty-req") - 1; *(s++) = 0x01; - libssh2_htonu32(s, term_len); + _libssh2_htonu32(s, term_len); s += 4; if (term) { memcpy(s, term, term_len); s += term_len; } - libssh2_htonu32(s, width); + _libssh2_htonu32(s, width); s += 4; - libssh2_htonu32(s, height); + _libssh2_htonu32(s, height); s += 4; - libssh2_htonu32(s, width_px); + _libssh2_htonu32(s, width_px); s += 4; - libssh2_htonu32(s, height_px); + _libssh2_htonu32(s, height_px); s += 4; - libssh2_htonu32(s, modes_len); + _libssh2_htonu32(s, modes_len); s += 4; if (modes) { memcpy(s, modes, modes_len); @@ -901,8 +902,8 @@ libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL * channel, const char *term, } if (channel->reqPTY_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, channel->reqPTY_packet, - channel->reqPTY_packet_len); + rc = _libssh2_packet_write(session, channel->reqPTY_packet, + channel->reqPTY_packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -916,15 +917,15 @@ libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL * channel, const char *term, LIBSSH2_FREE(session, channel->reqPTY_packet); channel->reqPTY_packet = NULL; - libssh2_htonu32(channel->reqPTY_local_channel, channel->local.id); + _libssh2_htonu32(channel->reqPTY_local_channel, channel->local.id); channel->reqPTY_state = libssh2_NB_state_sent; } if (channel->reqPTY_state == libssh2_NB_state_sent) { - rc = libssh2_packet_requirev(session, reply_codes, &data, &data_len, - 1, channel->reqPTY_local_channel, 4, - &channel->reqPTY_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len, + 1, channel->reqPTY_local_channel, 4, + &channel->reqPTY_packet_requirev_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -946,8 +947,6 @@ libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL * channel, const char *term, return -1; } -/* }}} */ - LIBSSH2_API int libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL * channel, int width, int height, int width_px, int height_px) @@ -961,7 +960,7 @@ libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL * channel, int width, /* Zero the whole thing out */ 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, "changing tty size on channel %lu/%lu", @@ -978,45 +977,45 @@ libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL * channel, int width, } *(s++) = SSH_MSG_CHANNEL_REQUEST; - libssh2_htonu32(s, channel->remote.id); + _libssh2_htonu32(s, channel->remote.id); s += 4; - libssh2_htonu32(s, sizeof("window-change") - 1); + _libssh2_htonu32(s, sizeof("window-change") - 1); s += 4; memcpy(s, "window-change", sizeof("window-change") - 1); s += sizeof("window-change") - 1; *(s++) = 0x00; /* Don't reply */ - libssh2_htonu32(s, width); + _libssh2_htonu32(s, width); s += 4; - libssh2_htonu32(s, height); + _libssh2_htonu32(s, height); s += 4; - libssh2_htonu32(s, width_px); + _libssh2_htonu32(s, width_px); s += 4; - libssh2_htonu32(s, height_px); + _libssh2_htonu32(s, height_px); s += 4; channel->reqPTY_state = libssh2_NB_state_created; } if (channel->reqPTY_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, channel->reqPTY_packet, - channel->reqPTY_packet_len); + rc = _libssh2_packet_write(session, channel->reqPTY_packet, + channel->reqPTY_packet_len); if (rc == PACKET_EAGAIN) { - return PACKET_EAGAIN; - } else if (rc) { - libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, - "Unable to send window-change packet", 0); + return PACKET_EAGAIN; + } else if (rc) { + libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, + "Unable to send window-change packet", 0); + LIBSSH2_FREE(session, channel->reqPTY_packet); + channel->reqPTY_packet = NULL; + channel->reqPTY_state = libssh2_NB_state_idle; + return -1; + } LIBSSH2_FREE(session, channel->reqPTY_packet); channel->reqPTY_packet = NULL; - channel->reqPTY_state = libssh2_NB_state_idle; - return -1; - } - LIBSSH2_FREE(session, channel->reqPTY_packet); - channel->reqPTY_packet = NULL; - libssh2_htonu32(channel->reqPTY_local_channel, channel->local.id); - channel->reqPTY_state = libssh2_NB_state_sent; + _libssh2_htonu32(channel->reqPTY_local_channel, channel->local.id); + channel->reqPTY_state = libssh2_NB_state_sent; - return 0; + return 0; } channel->reqPTY_state = libssh2_NB_state_idle; @@ -1026,7 +1025,8 @@ libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL * channel, int width, /* Keep this an even number */ #define LIBSSH2_X11_RANDOM_COOKIE_LEN 32 -/* {{{ libssh2_channel_x11_req_ex +/* + * libssh2_channel_x11_req_ex * Request X11 forwarding */ LIBSSH2_API int @@ -1072,9 +1072,9 @@ libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL * channel, int single_connection, } *(s++) = SSH_MSG_CHANNEL_REQUEST; - libssh2_htonu32(s, channel->remote.id); + _libssh2_htonu32(s, channel->remote.id); s += 4; - libssh2_htonu32(s, sizeof("x11-req") - 1); + _libssh2_htonu32(s, sizeof("x11-req") - 1); s += 4; memcpy(s, "x11-req", sizeof("x11-req") - 1); s += sizeof("x11-req") - 1; @@ -1082,12 +1082,12 @@ libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL * channel, int single_connection, *(s++) = 0x01; /* want_reply */ *(s++) = single_connection ? 0x01 : 0x00; - libssh2_htonu32(s, proto_len); + _libssh2_htonu32(s, proto_len); s += 4; memcpy(s, auth_proto ? auth_proto : "MIT-MAGIC-COOKIE-1", proto_len); s += proto_len; - libssh2_htonu32(s, cookie_len); + _libssh2_htonu32(s, cookie_len); s += 4; if (auth_cookie) { memcpy(s, auth_cookie, cookie_len); @@ -1106,15 +1106,15 @@ libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL * channel, int single_connection, } s += cookie_len; - libssh2_htonu32(s, screen_number); + _libssh2_htonu32(s, screen_number); s += 4; channel->reqX11_state = libssh2_NB_state_created; } if (channel->reqX11_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, channel->reqX11_packet, - channel->reqX11_packet_len); + rc = _libssh2_packet_write(session, channel->reqX11_packet, + channel->reqX11_packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } @@ -1129,15 +1129,15 @@ libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL * channel, int single_connection, LIBSSH2_FREE(session, channel->reqX11_packet); channel->reqX11_packet = NULL; - libssh2_htonu32(channel->reqX11_local_channel, channel->local.id); + _libssh2_htonu32(channel->reqX11_local_channel, channel->local.id); channel->reqX11_state = libssh2_NB_state_sent; } if (channel->reqX11_state == libssh2_NB_state_sent) { - rc = libssh2_packet_requirev(session, reply_codes, &data, &data_len, - 1, channel->reqX11_local_channel, 4, - &channel->reqX11_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len, + 1, channel->reqX11_local_channel, 4, + &channel->reqX11_packet_requirev_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -1158,9 +1158,9 @@ libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL * channel, int single_connection, return -1; } -/* }}} */ - -/* {{{ libssh2_channel_process_startup +/* + * libssh2_channel_process_startup + * * Primitive for libssh2_channel_(shell|exec|subsystem) */ LIBSSH2_API int @@ -1201,9 +1201,9 @@ libssh2_channel_process_startup(LIBSSH2_CHANNEL * channel, const char *request, } *(s++) = SSH_MSG_CHANNEL_REQUEST; - libssh2_htonu32(s, channel->remote.id); + _libssh2_htonu32(s, channel->remote.id); s += 4; - libssh2_htonu32(s, request_len); + _libssh2_htonu32(s, request_len); s += 4; memcpy(s, request, request_len); s += request_len; @@ -1211,7 +1211,7 @@ libssh2_channel_process_startup(LIBSSH2_CHANNEL * channel, const char *request, *(s++) = 0x01; if (message) { - libssh2_htonu32(s, message_len); + _libssh2_htonu32(s, message_len); s += 4; memcpy(s, message, message_len); s += message_len; @@ -1221,8 +1221,8 @@ libssh2_channel_process_startup(LIBSSH2_CHANNEL * channel, const char *request, } if (channel->process_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, channel->process_packet, - channel->process_packet_len); + rc = _libssh2_packet_write(session, channel->process_packet, + channel->process_packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -1236,15 +1236,15 @@ libssh2_channel_process_startup(LIBSSH2_CHANNEL * channel, const char *request, LIBSSH2_FREE(session, channel->process_packet); channel->process_packet = NULL; - libssh2_htonu32(channel->process_local_channel, channel->local.id); + _libssh2_htonu32(channel->process_local_channel, channel->local.id); channel->process_state = libssh2_NB_state_sent; } if (channel->process_state == libssh2_NB_state_sent) { - rc = libssh2_packet_requirev(session, reply_codes, &data, &data_len, - 1, channel->process_local_channel, 4, - &channel->process_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len, + 1, channel->process_local_channel, 4, + &channel->process_packet_requirev_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -1266,9 +1266,9 @@ libssh2_channel_process_startup(LIBSSH2_CHANNEL * channel, const char *request, return -1; } -/* }}} */ - -/* {{{ libssh2_channel_set_blocking +/* + * libssh2_channel_set_blocking + * * Set a channel's blocking mode on or off, similar to a socket's * fcntl(fd, F_SETFL, O_NONBLOCK); type command */ @@ -1278,9 +1278,9 @@ libssh2_channel_set_blocking(LIBSSH2_CHANNEL * channel, int blocking) (void) _libssh2_session_set_blocking(channel->session, blocking); } -/* }}} */ - -/* {{{ libssh2_channel_flush_ex +/* + * libssh2_channel_flush_ex + * * Flush data from one (or all) stream * Returns number of bytes flushed, or -1 on failure */ @@ -1299,11 +1299,11 @@ libssh2_channel_flush_ex(LIBSSH2_CHANNEL * channel, int streamid) if (((packet_type == SSH_MSG_CHANNEL_DATA) || (packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA)) - && (libssh2_ntohu32(packet->data + 1) == channel->local.id)) { + && (_libssh2_ntohu32(packet->data + 1) == channel->local.id)) { /* It's our channel at least */ long packet_stream_id = (packet_type == - SSH_MSG_CHANNEL_DATA) ? 0 : libssh2_ntohu32(packet->data + + SSH_MSG_CHANNEL_DATA) ? 0 : _libssh2_ntohu32(packet->data + 5); if ((streamid == LIBSSH2_CHANNEL_FLUSH_ALL) || ((packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA) @@ -1359,9 +1359,9 @@ libssh2_channel_flush_ex(LIBSSH2_CHANNEL * channel, int streamid) return channel->flush_flush_bytes; } -/* }}} */ - -/* {{{ libssh2_channel_get_exit_status +/* + * libssh2_channel_get_exit_status + * * Return the channel's program exit status */ LIBSSH2_API int @@ -1370,8 +1370,6 @@ libssh2_channel_get_exit_status(LIBSSH2_CHANNEL * channel) return channel->exit_status; } -/* }}} */ - /* * libssh2_channel_receive_window_adjust * @@ -1410,8 +1408,8 @@ libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel, /* Adjust the window based on the block we just freed */ channel->adjust_adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST; - libssh2_htonu32(&channel->adjust_adjust[1], channel->remote.id); - libssh2_htonu32(&channel->adjust_adjust[5], adjustment); + _libssh2_htonu32(&channel->adjust_adjust[1], channel->remote.id); + _libssh2_htonu32(&channel->adjust_adjust[5], adjustment); _libssh2_debug(channel->session, LIBSSH2_DBG_CONN, "Adjusting window %lu bytes for data on " "channel %lu/%lu", @@ -1420,7 +1418,7 @@ libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel, channel->adjust_state = libssh2_NB_state_created; } - rc = libssh2_packet_write(channel->session, channel->adjust_adjust, 9); + rc = _libssh2_packet_write(channel->session, channel->adjust_adjust, 9); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; /* TODO/FIX: this function returns an unsigned value! */ @@ -1440,9 +1438,8 @@ libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel, return channel->remote.window_size; } -/* }}} */ - -/* {{{ libssh2_channel_handle_extended_data +/* + * libssh2_channel_handle_extended_data * * How should extended data look to the calling app? Keep it in separate * channels[_read() _read_stdder()]? (NORMAL) Merge the extended data to the @@ -1515,7 +1512,7 @@ libssh2_channel_read_ex(LIBSSH2_CHANNEL * channel, int stream_id, char *buf, /* process all pending incoming packets */ while (rc > 0) - rc = libssh2_packet_read(session); + rc = _libssh2_packet_read(session); if ((rc < 0) && (rc != PACKET_EAGAIN)) return -1; @@ -1526,7 +1523,7 @@ libssh2_channel_read_ex(LIBSSH2_CHANNEL * channel, int stream_id, char *buf, /* We're not in the idle state, but in order to "even out" the network readings we do a single shot read here as well. Tests prove that this way produces faster transfers. */ - rc = libssh2_packet_read(session); + rc = _libssh2_packet_read(session); /* ignore PACKET_EAGAIN but return failure for the rest */ if ((rc < 0) && (rc != PACKET_EAGAIN)) @@ -1554,7 +1551,7 @@ libssh2_channel_read_ex(LIBSSH2_CHANNEL * channel, int stream_id, char *buf, channel->read_next = readpkt->next; channel->read_local_id = - libssh2_ntohu32(readpkt->data + 1); + _libssh2_ntohu32(readpkt->data + 1); /* * Either we asked for a specific extended data stream @@ -1566,7 +1563,7 @@ libssh2_channel_read_ex(LIBSSH2_CHANNEL * channel, int stream_id, char *buf, if ((stream_id && (readpkt->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA) && (channel->local.id == channel->read_local_id) - && (stream_id == (int) libssh2_ntohu32(readpkt->data + 5))) + && (stream_id == (int) _libssh2_ntohu32(readpkt->data + 5))) || (!stream_id && (readpkt->data[0] == SSH_MSG_CHANNEL_DATA) && (channel->local.id == channel->read_local_id)) || (!stream_id @@ -1668,13 +1665,13 @@ libssh2_channel_read_ex(LIBSSH2_CHANNEL * channel, int stream_id, char *buf, } /* - * libssh2_channel_packet_data_len + * _libssh2_channel_packet_data_len * * Return the size of the data block of the current packet, or 0 if there * isn't a packet. */ unsigned long -libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id) +_libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id) { LIBSSH2_SESSION *session = channel->session; LIBSSH2_PACKET *read_packet; @@ -1685,7 +1682,7 @@ libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id) } while (read_packet) { - read_local_id = libssh2_ntohu32(read_packet->data + 1); + read_local_id = _libssh2_ntohu32(read_packet->data + 1); /* * Either we asked for a specific extended data stream @@ -1697,7 +1694,7 @@ libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id) if ((stream_id && (read_packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA) && (channel->local.id == read_local_id) - && (stream_id == (int) libssh2_ntohu32(read_packet->data + 5))) + && (stream_id == (int) _libssh2_ntohu32(read_packet->data + 5))) || (!stream_id && (read_packet->data[0] == SSH_MSG_CHANNEL_DATA) && (channel->local.id == read_local_id)) || (!stream_id @@ -1780,10 +1777,10 @@ libssh2_channel_write_ex(LIBSSH2_CHANNEL * channel, int stream_id, *(channel->write_s++) = stream_id ? SSH_MSG_CHANNEL_EXTENDED_DATA : SSH_MSG_CHANNEL_DATA; - libssh2_htonu32(channel->write_s, channel->remote.id); + _libssh2_htonu32(channel->write_s, channel->remote.id); channel->write_s += 4; if (stream_id) { - libssh2_htonu32(channel->write_s, stream_id); + _libssh2_htonu32(channel->write_s, stream_id); channel->write_s += 4; } @@ -1791,7 +1788,7 @@ libssh2_channel_write_ex(LIBSSH2_CHANNEL * channel, int stream_id, while (channel->local.window_size <= 0) { /* Don't worry -- This is never hit unless it's a blocking channel anyway */ - rc = libssh2_packet_read(session); + rc = _libssh2_packet_read(session); if (rc < 0) { /* Error or EAGAIN occurred, disconnect? */ @@ -1830,7 +1827,7 @@ libssh2_channel_write_ex(LIBSSH2_CHANNEL * channel, int stream_id, channel->remote.id, stream_id); channel->write_bufwrite = channel->local.packet_size; } - libssh2_htonu32(channel->write_s, channel->write_bufwrite); + _libssh2_htonu32(channel->write_s, channel->write_bufwrite); channel->write_s += 4; memcpy(channel->write_s, buf, channel->write_bufwrite); channel->write_s += channel->write_bufwrite; @@ -1844,9 +1841,9 @@ libssh2_channel_write_ex(LIBSSH2_CHANNEL * channel, int stream_id, } if (channel->write_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, channel->write_packet, - channel->write_s - - channel->write_packet); + rc = _libssh2_packet_write(session, channel->write_packet, + channel->write_s - + channel->write_packet); if (rc == PACKET_EAGAIN) { _libssh2_debug(session, LIBSSH2_DBG_CONN, "libssh2_packet_write returned EAGAIN"); @@ -1887,9 +1884,9 @@ libssh2_channel_write_ex(LIBSSH2_CHANNEL * channel, int stream_id, return channel->write_bufwrote; } -/* }}} */ - -/* {{{ libssh2_channel_send_eof +/* + * libssh2_channel_send_eof + * * Send EOF on channel */ LIBSSH2_API int @@ -1902,8 +1899,8 @@ libssh2_channel_send_eof(LIBSSH2_CHANNEL * channel) _libssh2_debug(session, LIBSSH2_DBG_CONN, "Sending EOF on channel %lu/%lu", channel->local.id, channel->remote.id); packet[0] = SSH_MSG_CHANNEL_EOF; - libssh2_htonu32(packet + 1, channel->remote.id); - rc = libssh2_packet_write(session, packet, 5); + _libssh2_htonu32(packet + 1, channel->remote.id); + rc = _libssh2_packet_write(session, packet, 5); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -1916,9 +1913,9 @@ libssh2_channel_send_eof(LIBSSH2_CHANNEL * channel) return 0; } -/* }}} */ - -/* {{{ libssh2_channel_eof +/* + * libssh2_channel_eof + * * Read channel's eof status */ LIBSSH2_API int @@ -1930,7 +1927,7 @@ libssh2_channel_eof(LIBSSH2_CHANNEL * channel) while (packet) { if (((packet->data[0] == SSH_MSG_CHANNEL_DATA) || (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)) - && (channel->local.id == libssh2_ntohu32(packet->data + 1))) { + && (channel->local.id == _libssh2_ntohu32(packet->data + 1))) { /* There's data waiting to be read yet, mask the EOF status */ return 0; } @@ -1940,11 +1937,11 @@ libssh2_channel_eof(LIBSSH2_CHANNEL * channel) return channel->remote.eof; } -/* }}} */ - -/* {{{ libssh2_channel_wait_eof -* Awaiting channel EOF -*/ +/* + * libssh2_channel_wait_eof + * + * Awaiting channel EOF + */ LIBSSH2_API int libssh2_channel_wait_eof(LIBSSH2_CHANNEL * channel) { @@ -1967,7 +1964,7 @@ libssh2_channel_wait_eof(LIBSSH2_CHANNEL * channel) if (channel->remote.eof) { break; } - rc = libssh2_packet_read(session); + rc = _libssh2_packet_read(session); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc < 0) { @@ -1981,10 +1978,9 @@ libssh2_channel_wait_eof(LIBSSH2_CHANNEL * channel) return 0; } -/* }}} */ - - -/* {{{ libssh2_channel_close +/* + * libssh2_channel_close + * * Close a channel */ LIBSSH2_API int @@ -2011,13 +2007,13 @@ libssh2_channel_close(LIBSSH2_CHANNEL * channel) channel->local.close = 1; channel->close_packet[0] = SSH_MSG_CHANNEL_CLOSE; - libssh2_htonu32(channel->close_packet + 1, channel->remote.id); + _libssh2_htonu32(channel->close_packet + 1, channel->remote.id); channel->close_state = libssh2_NB_state_created; } if (channel->close_state == libssh2_NB_state_created) { - retcode = libssh2_packet_write(session, channel->close_packet, 5); + retcode = _libssh2_packet_write(session, channel->close_packet, 5); if (retcode == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (retcode) { @@ -2036,7 +2032,7 @@ libssh2_channel_close(LIBSSH2_CHANNEL * channel) libssh2pack_t ret; do { - ret = libssh2_packet_read(session); + ret = _libssh2_packet_read(session); if (ret == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (ret < 0) { @@ -2051,9 +2047,9 @@ libssh2_channel_close(LIBSSH2_CHANNEL * channel) return rc; } -/* }}} */ - -/* {{{ libssh2_channel_wait_closed +/* + * libssh2_channel_wait_closed + * * Awaiting channel close after EOF */ LIBSSH2_API int @@ -2086,7 +2082,7 @@ libssh2_channel_wait_closed(LIBSSH2_CHANNEL * channel) if (!channel->remote.close) { break; } - rc = libssh2_packet_read(session); + rc = _libssh2_packet_read(session); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc <= 0) { @@ -2099,10 +2095,9 @@ libssh2_channel_wait_closed(LIBSSH2_CHANNEL * channel) return 0; } -/* }}} */ - - -/* {{{ libssh2_channel_free +/* + * libssh2_channel_free + * * Make sure a channel is closed, then remove the channel from the session * and free its resource(s) * @@ -2144,12 +2139,12 @@ libssh2_channel_free(LIBSSH2_CHANNEL * channel) */ /* Clear out packets meant for this channel */ - libssh2_htonu32(channel_id, channel->local.id); - while ((libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA, &data, - &data_len, 1, channel_id, 4, 0) >= 0) + _libssh2_htonu32(channel_id, channel->local.id); + while ((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA, &data, + &data_len, 1, channel_id, 4, 0) >= 0) || - (libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA, &data, - &data_len, 1, channel_id, 4, 0) >= 0)) { + (_libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA, &data, + &data_len, 1, channel_id, 4, 0) >= 0)) { LIBSSH2_FREE(session, data); } @@ -2194,9 +2189,8 @@ libssh2_channel_free(LIBSSH2_CHANNEL * channel) return 0; } -/* }}} */ - -/* {{{ libssh2_channel_window_read_ex +/* + * libssh2_channel_window_read_ex * * Check the status of the read window. Returns the number of bytes which the * remote end may send without overflowing the window limit read_avail (if @@ -2222,7 +2216,7 @@ libssh2_channel_window_read_ex(LIBSSH2_CHANNEL * channel, if (((packet_type == SSH_MSG_CHANNEL_DATA) || (packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA)) - && (libssh2_ntohu32(packet->data + 1) == channel->local.id)) { + && (_libssh2_ntohu32(packet->data + 1) == channel->local.id)) { bytes_queued += packet->data_len - packet->data_head; } @@ -2235,9 +2229,8 @@ libssh2_channel_window_read_ex(LIBSSH2_CHANNEL * channel, return channel->remote.window_size; } -/* }}} */ - -/* {{{ libssh2_channel_window_write_ex +/* + * libssh2_channel_window_write_ex * * Check the status of the write window Returns the number of bytes which may * be safely writen on the channel without blocking window_size_initial (if @@ -2256,5 +2249,3 @@ libssh2_channel_window_write_ex(LIBSSH2_CHANNEL * channel, return channel->local.window_size; } - -/* }}} */ diff --git a/src/comp.c b/src/comp.c index e8c83c8..111267d 100644 --- a/src/comp.c +++ b/src/comp.c @@ -44,18 +44,20 @@ * none * ******** */ -/* {{{ libssh2_comp_method_none_comp +/* + * comp_method_none_comp + * * Minimalist compression: Absolutely none */ static int -libssh2_comp_method_none_comp(LIBSSH2_SESSION * session, - int compress, - unsigned char **dest, - unsigned long *dest_len, - unsigned long payload_limit, - int *free_dest, - const unsigned char *src, - unsigned long src_len, void **abstract) +comp_method_none_comp(LIBSSH2_SESSION * session, + int compress, + unsigned char **dest, + unsigned long *dest_len, + unsigned long payload_limit, + int *free_dest, + const unsigned char *src, + unsigned long src_len, void **abstract) { (void) session; (void) compress; @@ -71,10 +73,10 @@ libssh2_comp_method_none_comp(LIBSSH2_SESSION * session, /* }}} */ -static const LIBSSH2_COMP_METHOD libssh2_comp_method_none = { +static const LIBSSH2_COMP_METHOD comp_method_none = { "none", NULL, - libssh2_comp_method_none_comp, + comp_method_none_comp, NULL }; @@ -326,7 +328,7 @@ static const LIBSSH2_COMP_METHOD libssh2_comp_method_zlib = { *********************** */ static const LIBSSH2_COMP_METHOD *_libssh2_comp_methods[] = { - &libssh2_comp_method_none, + &comp_method_none, #ifdef LIBSSH2_HAVE_ZLIB &libssh2_comp_method_zlib, #endif /* LIBSSH2_HAVE_ZLIB */ diff --git a/src/crypt.c b/src/crypt.c index 2f32877..9f7b55c 100644 --- a/src/crypt.c +++ b/src/crypt.c @@ -38,27 +38,26 @@ #include "libssh2_priv.h" #ifdef LIBSSH2_CRYPT_NONE -/* {{{ libssh2_crypt_none_crypt + +/* crypt_none_crypt * Minimalist cipher: VERY secure *wink* */ static int -libssh2_crypt_none_crypt(LIBSSH2_SESSION * session, unsigned char *buf, +crypt_none_crypt(LIBSSH2_SESSION * session, unsigned char *buf, void **abstract) { /* Do nothing to the data! */ return 0; } -/* }}} */ - static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_none = { "none", - 8, /* blocksize (SSH2 defines minimum blocksize as 8) */ - 0, /* iv_len */ - 0, /* secret_len */ - 0, /* flags */ + 8, /* blocksize (SSH2 defines minimum blocksize as 8) */ + 0, /* iv_len */ + 0, /* secret_len */ + 0, /* flags */ NULL, - libssh2_crypt_none_crypt, + crypt_none_crypt, NULL }; #endif /* LIBSSH2_CRYPT_NONE */ @@ -66,16 +65,16 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_none = { struct crypt_ctx { int encrypt; - _libssh2_cipher_type(algo); + _libssh2_cipher_type(algo); _libssh2_cipher_ctx h; }; static int -_libssh2_init(LIBSSH2_SESSION * session, - const LIBSSH2_CRYPT_METHOD * method, - unsigned char *iv, int *free_iv, - unsigned char *secret, int *free_secret, - int encrypt, void **abstract) +crypt_init(LIBSSH2_SESSION * session, + const LIBSSH2_CRYPT_METHOD * method, + unsigned char *iv, int *free_iv, + unsigned char *secret, int *free_secret, + int encrypt, void **abstract) { struct crypt_ctx *ctx = LIBSSH2_ALLOC(session, sizeof(struct crypt_ctx)); @@ -95,7 +94,7 @@ _libssh2_init(LIBSSH2_SESSION * session, } static int -_libssh2_encrypt(LIBSSH2_SESSION * session, unsigned char *block, +crypt_encrypt(LIBSSH2_SESSION * session, unsigned char *block, void **abstract) { struct crypt_ctx *cctx = *(struct crypt_ctx **) abstract; @@ -104,7 +103,7 @@ _libssh2_encrypt(LIBSSH2_SESSION * session, unsigned char *block, } static int -_libssh2_dtor(LIBSSH2_SESSION * session, void **abstract) +crypt_dtor(LIBSSH2_SESSION * session, void **abstract) { struct crypt_ctx **cctx = (struct crypt_ctx **) abstract; if (cctx && *cctx) { @@ -122,9 +121,9 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_cbc = { 16, /* initial value length */ 16, /* secret length -- 16*8 == 128bit */ 0, /* flags */ - &_libssh2_init, - &_libssh2_encrypt, - &_libssh2_dtor, + &crypt_init, + &crypt_encrypt, + &crypt_dtor, _libssh2_cipher_aes128 }; @@ -134,9 +133,9 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes192_cbc = { 16, /* initial value length */ 24, /* secret length -- 24*8 == 192bit */ 0, /* flags */ - &_libssh2_init, - &_libssh2_encrypt, - &_libssh2_dtor, + &crypt_init, + &crypt_encrypt, + &crypt_dtor, _libssh2_cipher_aes192 }; @@ -146,9 +145,9 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_cbc = { 16, /* initial value length */ 32, /* secret length -- 32*8 == 256bit */ 0, /* flags */ - &_libssh2_init, - &_libssh2_encrypt, - &_libssh2_dtor, + &crypt_init, + &crypt_encrypt, + &crypt_dtor, _libssh2_cipher_aes256 }; @@ -160,9 +159,9 @@ static const LIBSSH2_CRYPT_METHOD 16, /* initial value length */ 32, /* secret length -- 32*8 == 256bit */ 0, /* flags */ - &_libssh2_init, - &_libssh2_encrypt, - &_libssh2_dtor, + &crypt_init, + &crypt_encrypt, + &crypt_dtor, _libssh2_cipher_aes256 }; #endif /* LIBSSH2_AES */ @@ -174,9 +173,9 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_blowfish_cbc = { 8, /* initial value length */ 16, /* secret length */ 0, /* flags */ - &_libssh2_init, - &_libssh2_encrypt, - &_libssh2_dtor, + &crypt_init, + &crypt_encrypt, + &crypt_dtor, _libssh2_cipher_blowfish }; #endif /* LIBSSH2_BLOWFISH */ @@ -188,9 +187,9 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_arcfour = { 8, /* initial value length */ 16, /* secret length */ 0, /* flags */ - &_libssh2_init, - &_libssh2_encrypt, - &_libssh2_dtor, + &crypt_init, + &crypt_encrypt, + &crypt_dtor, _libssh2_cipher_arcfour }; #endif /* LIBSSH2_RC4 */ @@ -202,9 +201,9 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_cast128_cbc = { 8, /* initial value length */ 16, /* secret length */ 0, /* flags */ - &_libssh2_init, - &_libssh2_encrypt, - &_libssh2_dtor, + &crypt_init, + &crypt_encrypt, + &crypt_dtor, _libssh2_cipher_cast5 }; #endif /* LIBSSH2_CAST */ @@ -216,9 +215,9 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_3des_cbc = { 8, /* initial value length */ 24, /* secret length */ 0, /* flags */ - &_libssh2_init, - &_libssh2_encrypt, - &_libssh2_dtor, + &crypt_init, + &crypt_encrypt, + &crypt_dtor, _libssh2_cipher_3des }; #endif diff --git a/src/hostkey.c b/src/hostkey.c index b25fd31..55a20d6 100644 --- a/src/hostkey.c +++ b/src/hostkey.c @@ -47,17 +47,19 @@ * ssh-rsa * *********** */ -static int libssh2_hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session, - void **abstract); +static int hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session, + void **abstract); -/* {{{ libssh2_hostkey_method_ssh_rsa_init +/* + * hostkey_method_ssh_rsa_init + * * Initialize the server hostkey working area with e/n pair */ static int -libssh2_hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session, - const unsigned char *hostkey_data, - unsigned long hostkey_data_len, - void **abstract) +hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session, + const unsigned char *hostkey_data, + unsigned long hostkey_data_len, + void **abstract) { libssh2_rsa_ctx *rsactx; const unsigned char *s, *e, *n; @@ -66,12 +68,12 @@ libssh2_hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session, (void) hostkey_data_len; if (*abstract) { - libssh2_hostkey_method_ssh_rsa_dtor(session, abstract); + hostkey_method_ssh_rsa_dtor(session, abstract); *abstract = NULL; } s = hostkey_data; - len = libssh2_ntohu32(s); + len = _libssh2_ntohu32(s); s += 4; if (len != 7 || strncmp((char *) s, "ssh-rsa", 7) != 0) { @@ -79,12 +81,12 @@ libssh2_hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session, } s += 7; - e_len = libssh2_ntohu32(s); + e_len = _libssh2_ntohu32(s); s += 4; e = s; s += e_len; - n_len = libssh2_ntohu32(s); + n_len = _libssh2_ntohu32(s); s += 4; n = s; s += n_len; @@ -98,23 +100,23 @@ libssh2_hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session, return 0; } -/* }}} */ - -/* {{{ libssh2_hostkey_method_ssh_rsa_initPEM +/* + * hostkey_method_ssh_rsa_initPEM + * * Load a Private Key from a PEM file */ static int -libssh2_hostkey_method_ssh_rsa_initPEM(LIBSSH2_SESSION * session, - const char *privkeyfile, - unsigned const char *passphrase, - void **abstract) +hostkey_method_ssh_rsa_initPEM(LIBSSH2_SESSION * session, + const char *privkeyfile, + unsigned const char *passphrase, + void **abstract) { libssh2_rsa_ctx *rsactx; FILE *fp; int ret; if (*abstract) { - libssh2_hostkey_method_ssh_rsa_dtor(session, abstract); + hostkey_method_ssh_rsa_dtor(session, abstract); *abstract = NULL; } @@ -134,17 +136,17 @@ libssh2_hostkey_method_ssh_rsa_initPEM(LIBSSH2_SESSION * session, return 0; } -/* }}} */ - -/* {{{ libssh2_hostkey_method_ssh_rsa_sign +/* + * hostkey_method_ssh_rsa_sign + * * Verify signature created by remote */ static int -libssh2_hostkey_method_ssh_rsa_sig_verify(LIBSSH2_SESSION * session, - const unsigned char *sig, - unsigned long sig_len, - const unsigned char *m, - unsigned long m_len, void **abstract) +hostkey_method_ssh_rsa_sig_verify(LIBSSH2_SESSION * session, + const unsigned char *sig, + unsigned long sig_len, + const unsigned char *m, + unsigned long m_len, void **abstract) { libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract); (void) session; @@ -155,18 +157,18 @@ libssh2_hostkey_method_ssh_rsa_sig_verify(LIBSSH2_SESSION * session, return _libssh2_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len); } -/* }}} */ - -/* {{{ libssh2_hostkey_method_ssh_rsa_signv +/* + * hostkey_method_ssh_rsa_signv + * * Construct a signature from an array of vectors */ static int -libssh2_hostkey_method_ssh_rsa_signv(LIBSSH2_SESSION * session, - unsigned char **signature, - unsigned long *signature_len, - unsigned long veccount, - const struct iovec datavec[], - void **abstract) +hostkey_method_ssh_rsa_signv(LIBSSH2_SESSION * session, + unsigned char **signature, + unsigned long *signature_len, + unsigned long veccount, + const struct iovec datavec[], + void **abstract) { libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract); int ret; @@ -189,13 +191,13 @@ libssh2_hostkey_method_ssh_rsa_signv(LIBSSH2_SESSION * session, return 0; } -/* }}} */ - -/* {{{ libssh2_hostkey_method_ssh_rsa_dtor +/* + * hostkey_method_ssh_rsa_dtor + * * Shutdown the hostkey */ static int -libssh2_hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session, void **abstract) +hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session, void **abstract) { libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract); (void) session; @@ -207,17 +209,15 @@ libssh2_hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session, void **abstract) return 0; } -/* }}} */ - -static const LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_rsa = { +static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_rsa = { "ssh-rsa", MD5_DIGEST_LENGTH, - libssh2_hostkey_method_ssh_rsa_init, - libssh2_hostkey_method_ssh_rsa_initPEM, - libssh2_hostkey_method_ssh_rsa_sig_verify, - libssh2_hostkey_method_ssh_rsa_signv, + hostkey_method_ssh_rsa_init, + hostkey_method_ssh_rsa_initPEM, + hostkey_method_ssh_rsa_sig_verify, + hostkey_method_ssh_rsa_signv, NULL, /* encrypt */ - libssh2_hostkey_method_ssh_rsa_dtor, + hostkey_method_ssh_rsa_dtor, }; #endif /* LIBSSH2_RSA */ @@ -226,17 +226,19 @@ static const LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_rsa = { * ssh-dss * *********** */ -static int libssh2_hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session, - void **abstract); +static int hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session, + void **abstract); -/* {{{ libssh2_hostkey_method_ssh_dss_init +/* + * hostkey_method_ssh_dss_init + * * Initialize the server hostkey working area with p/q/g/y set */ static int -libssh2_hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session, - const unsigned char *hostkey_data, - unsigned long hostkey_data_len, - void **abstract) +hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session, + const unsigned char *hostkey_data, + unsigned long hostkey_data_len, + void **abstract) { libssh2_dsa_ctx *dsactx; const unsigned char *p, *q, *g, *y, *s; @@ -244,31 +246,31 @@ libssh2_hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session, (void) hostkey_data_len; if (*abstract) { - libssh2_hostkey_method_ssh_dss_dtor(session, abstract); + hostkey_method_ssh_dss_dtor(session, abstract); *abstract = NULL; } s = hostkey_data; - len = libssh2_ntohu32(s); + len = _libssh2_ntohu32(s); s += 4; if (len != 7 || strncmp((char *) s, "ssh-dss", 7) != 0) { return -1; } s += 7; - p_len = libssh2_ntohu32(s); + p_len = _libssh2_ntohu32(s); s += 4; p = s; s += p_len; - q_len = libssh2_ntohu32(s); + q_len = _libssh2_ntohu32(s); s += 4; q = s; s += q_len; - g_len = libssh2_ntohu32(s); + g_len = _libssh2_ntohu32(s); s += 4; g = s; s += g_len; - y_len = libssh2_ntohu32(s); + y_len = _libssh2_ntohu32(s); s += 4; y = s; s += y_len; @@ -280,23 +282,23 @@ libssh2_hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session, return 0; } -/* }}} */ - -/* {{{ libssh2_hostkey_method_ssh_dss_initPEM +/* + * hostkey_method_ssh_dss_initPEM + * * Load a Private Key from a PEM file */ static int -libssh2_hostkey_method_ssh_dss_initPEM(LIBSSH2_SESSION * session, - const char *privkeyfile, - unsigned const char *passphrase, - void **abstract) +hostkey_method_ssh_dss_initPEM(LIBSSH2_SESSION * session, + const char *privkeyfile, + unsigned const char *passphrase, + void **abstract) { libssh2_dsa_ctx *dsactx; FILE *fp; int ret; if (*abstract) { - libssh2_hostkey_method_ssh_dss_dtor(session, abstract); + hostkey_method_ssh_dss_dtor(session, abstract); *abstract = NULL; } @@ -316,17 +318,17 @@ libssh2_hostkey_method_ssh_dss_initPEM(LIBSSH2_SESSION * session, return 0; } -/* }}} */ - -/* {{{ libssh2_hostkey_method_ssh_dss_sign +/* + * libssh2_hostkey_method_ssh_dss_sign + * * Verify signature created by remote */ static int -libssh2_hostkey_method_ssh_dss_sig_verify(LIBSSH2_SESSION * session, - const unsigned char *sig, - unsigned long sig_len, - const unsigned char *m, - unsigned long m_len, void **abstract) +hostkey_method_ssh_dss_sig_verify(LIBSSH2_SESSION * session, + const unsigned char *sig, + unsigned long sig_len, + const unsigned char *m, + unsigned long m_len, void **abstract) { libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract); @@ -341,18 +343,18 @@ libssh2_hostkey_method_ssh_dss_sig_verify(LIBSSH2_SESSION * session, return _libssh2_dsa_sha1_verify(dsactx, sig, m, m_len); } -/* }}} */ - -/* {{{ libssh2_hostkey_method_ssh_dss_signv +/* + * hostkey_method_ssh_dss_signv + * * Construct a signature from an array of vectors */ static int -libssh2_hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session, - unsigned char **signature, - unsigned long *signature_len, - unsigned long veccount, - const struct iovec datavec[], - void **abstract) +hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session, + unsigned char **signature, + unsigned long *signature_len, + unsigned long veccount, + const struct iovec datavec[], + void **abstract) { libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract); unsigned char hash[SHA_DIGEST_LENGTH]; @@ -381,13 +383,13 @@ libssh2_hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session, return 0; } -/* }}} */ - -/* {{{ libssh2_hostkey_method_ssh_dss_dtor +/* + * libssh2_hostkey_method_ssh_dss_dtor + * * Shutdown the hostkey method */ static int -libssh2_hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session, void **abstract) +hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session, void **abstract) { libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract); (void) session; @@ -399,26 +401,24 @@ libssh2_hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session, void **abstract) return 0; } -/* }}} */ - -static const LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_dss = { +static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_dss = { "ssh-dss", MD5_DIGEST_LENGTH, - libssh2_hostkey_method_ssh_dss_init, - libssh2_hostkey_method_ssh_dss_initPEM, - libssh2_hostkey_method_ssh_dss_sig_verify, - libssh2_hostkey_method_ssh_dss_signv, + hostkey_method_ssh_dss_init, + hostkey_method_ssh_dss_initPEM, + hostkey_method_ssh_dss_sig_verify, + hostkey_method_ssh_dss_signv, NULL, /* encrypt */ - libssh2_hostkey_method_ssh_dss_dtor, + hostkey_method_ssh_dss_dtor, }; #endif /* LIBSSH2_DSA */ -static const LIBSSH2_HOSTKEY_METHOD *_libssh2_hostkey_methods[] = { +static const LIBSSH2_HOSTKEY_METHOD *hostkey_methods[] = { #if LIBSSH2_RSA - &libssh2_hostkey_method_ssh_rsa, + &hostkey_method_ssh_rsa, #endif /* LIBSSH2_RSA */ #if LIBSSH2_DSA - &libssh2_hostkey_method_ssh_dss, + &hostkey_method_ssh_dss, #endif /* LIBSSH2_DSA */ NULL }; @@ -426,10 +426,12 @@ static const LIBSSH2_HOSTKEY_METHOD *_libssh2_hostkey_methods[] = { const LIBSSH2_HOSTKEY_METHOD ** libssh2_hostkey_methods(void) { - return _libssh2_hostkey_methods; + return hostkey_methods; } -/* {{{ libssh2_hostkey_hash +/* + * libssh2_hostkey_hash + * * Returns hash signature * Returned buffer should NOT be freed * Length of buffer is determined by hash type @@ -451,5 +453,3 @@ libssh2_hostkey_hash(LIBSSH2_SESSION * session, int hash_type) return NULL; } } - -/* }}} */ diff --git a/src/kex.c b/src/kex.c index 68a6d15..6249905 100644 --- a/src/kex.c +++ b/src/kex.c @@ -122,7 +122,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, goto clean_exit; } exchange_state->e_packet[0] = packet_type_init; - libssh2_htonu32(exchange_state->e_packet + 1, + _libssh2_htonu32(exchange_state->e_packet + 1, exchange_state->e_packet_len - 5); if (_libssh2_bn_bits(exchange_state->e) % 8) { _libssh2_bn_to_bin(exchange_state->e, @@ -139,8 +139,8 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, } if (exchange_state->state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, exchange_state->e_packet, - exchange_state->e_packet_len); + rc = _libssh2_packet_write(session, exchange_state->e_packet, + exchange_state->e_packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -162,7 +162,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, _libssh2_debug(session, LIBSSH2_DBG_KEX, "Waiting for badly guessed KEX packet (to be ignored)"); burn_type = - libssh2_packet_burn(session, &exchange_state->burn_state); + _libssh2_packet_burn(session, &exchange_state->burn_state); if (burn_type == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (burn_type <= 0) { @@ -182,10 +182,10 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, if (exchange_state->state == libssh2_NB_state_sent1) { /* Wait for KEX reply */ - rc = libssh2_packet_require(session, packet_type_reply, - &exchange_state->s_packet, - &exchange_state->s_packet_len, 0, NULL, - 0, &exchange_state->req_state); + rc = _libssh2_packet_require(session, packet_type_reply, + &exchange_state->s_packet, + &exchange_state->s_packet_len, 0, NULL, + 0, &exchange_state->req_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } @@ -199,7 +199,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, /* Parse KEXDH_REPLY */ exchange_state->s = exchange_state->s_packet + 1; - session->server_hostkey_len = libssh2_ntohu32(exchange_state->s); + session->server_hostkey_len = _libssh2_ntohu32(exchange_state->s); exchange_state->s += 4; session->server_hostkey = LIBSSH2_ALLOC(session, session->server_hostkey_len); @@ -268,14 +268,14 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, goto clean_exit; } - exchange_state->f_value_len = libssh2_ntohu32(exchange_state->s); + exchange_state->f_value_len = _libssh2_ntohu32(exchange_state->s); exchange_state->s += 4; exchange_state->f_value = exchange_state->s; exchange_state->s += exchange_state->f_value_len; _libssh2_bn_from_bin(exchange_state->f, exchange_state->f_value_len, exchange_state->f_value); - exchange_state->h_sig_len = libssh2_ntohu32(exchange_state->s); + exchange_state->h_sig_len = _libssh2_ntohu32(exchange_state->s); exchange_state->s += 4; exchange_state->h_sig = exchange_state->s; @@ -295,7 +295,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, ret = -1; goto clean_exit; } - libssh2_htonu32(exchange_state->k_value, + _libssh2_htonu32(exchange_state->k_value, exchange_state->k_value_len - 4); if (_libssh2_bn_bits(exchange_state->k) % 8) { _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4); @@ -306,7 +306,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, libssh2_sha1_init(&exchange_state->exchange_hash); if (session->local.banner) { - libssh2_htonu32(exchange_state->h_sig_comp, + _libssh2_htonu32(exchange_state->h_sig_comp, strlen((char *) session->local.banner) - 2); libssh2_sha1_update(exchange_state->exchange_hash, exchange_state->h_sig_comp, 4); @@ -314,7 +314,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, (char *) session->local.banner, strlen((char *) session->local.banner) - 2); } else { - libssh2_htonu32(exchange_state->h_sig_comp, + _libssh2_htonu32(exchange_state->h_sig_comp, sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1); libssh2_sha1_update(exchange_state->exchange_hash, exchange_state->h_sig_comp, 4); @@ -323,7 +323,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1); } - libssh2_htonu32(exchange_state->h_sig_comp, + _libssh2_htonu32(exchange_state->h_sig_comp, strlen((char *) session->remote.banner)); libssh2_sha1_update(exchange_state->exchange_hash, exchange_state->h_sig_comp, 4); @@ -331,7 +331,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, session->remote.banner, strlen((char *) session->remote.banner)); - libssh2_htonu32(exchange_state->h_sig_comp, + _libssh2_htonu32(exchange_state->h_sig_comp, session->local.kexinit_len); libssh2_sha1_update(exchange_state->exchange_hash, exchange_state->h_sig_comp, 4); @@ -339,7 +339,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, session->local.kexinit, session->local.kexinit_len); - libssh2_htonu32(exchange_state->h_sig_comp, + _libssh2_htonu32(exchange_state->h_sig_comp, session->remote.kexinit_len); libssh2_sha1_update(exchange_state->exchange_hash, exchange_state->h_sig_comp, 4); @@ -347,7 +347,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, session->remote.kexinit, session->remote.kexinit_len); - libssh2_htonu32(exchange_state->h_sig_comp, + _libssh2_htonu32(exchange_state->h_sig_comp, session->server_hostkey_len); libssh2_sha1_update(exchange_state->exchange_hash, exchange_state->h_sig_comp, 4); @@ -358,16 +358,16 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, if (packet_type_init == SSH_MSG_KEX_DH_GEX_INIT) { /* diffie-hellman-group-exchange hashes additional fields */ #ifdef LIBSSH2_DH_GEX_NEW - libssh2_htonu32(exchange_state->h_sig_comp, + _libssh2_htonu32(exchange_state->h_sig_comp, LIBSSH2_DH_GEX_MINGROUP); - libssh2_htonu32(exchange_state->h_sig_comp + 4, + _libssh2_htonu32(exchange_state->h_sig_comp + 4, LIBSSH2_DH_GEX_OPTGROUP); - libssh2_htonu32(exchange_state->h_sig_comp + 8, + _libssh2_htonu32(exchange_state->h_sig_comp + 8, LIBSSH2_DH_GEX_MAXGROUP); libssh2_sha1_update(exchange_state->exchange_hash, exchange_state->h_sig_comp, 12); #else - libssh2_htonu32(exchange_state->h_sig_comp, + _libssh2_htonu32(exchange_state->h_sig_comp, LIBSSH2_DH_GEX_OPTGROUP); libssh2_sha1_update(exchange_state->exchange_hash, exchange_state->h_sig_comp, 4); @@ -383,7 +383,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, exchange_state->e_packet + 1, exchange_state->e_packet_len - 1); - libssh2_htonu32(exchange_state->h_sig_comp, + _libssh2_htonu32(exchange_state->h_sig_comp, exchange_state->f_value_len); libssh2_sha1_update(exchange_state->exchange_hash, exchange_state->h_sig_comp, 4); @@ -415,7 +415,7 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, } if (exchange_state->state == libssh2_NB_state_sent2) { - rc = libssh2_packet_write(session, &exchange_state->c, 1); + rc = _libssh2_packet_write(session, &exchange_state->c, 1); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -429,10 +429,10 @@ kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *session, } if (exchange_state->state == libssh2_NB_state_sent3) { - rc = libssh2_packet_require(session, SSH_MSG_NEWKEYS, - &exchange_state->tmp, - &exchange_state->tmp_len, 0, NULL, 0, - &exchange_state->req_state); + rc = _libssh2_packet_require(session, SSH_MSG_NEWKEYS, + &exchange_state->tmp, + &exchange_state->tmp_len, 0, NULL, 0, + &exchange_state->req_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -819,15 +819,15 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange /* Ask for a P and G pair */ #ifdef LIBSSH2_DH_GEX_NEW key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST; - libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_MINGROUP); - 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 + 1, LIBSSH2_DH_GEX_MINGROUP); + _libssh2_htonu32(key_state->request + 5, LIBSSH2_DH_GEX_OPTGROUP); + _libssh2_htonu32(key_state->request + 9, LIBSSH2_DH_GEX_MAXGROUP); key_state->request_len = 13; _libssh2_debug(session, LIBSSH2_DBG_KEX, "Initiating Diffie-Hellman Group-Exchange (New Method)"); #else 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; _libssh2_debug(session, LIBSSH2_DBG_KEX, "Initiating Diffie-Hellman Group-Exchange (Old Method)"); @@ -837,8 +837,8 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange } if (key_state->state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, key_state->request, - key_state->request_len); + rc = _libssh2_packet_write(session, key_state->request, + key_state->request_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -852,9 +852,9 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange } if (key_state->state == libssh2_NB_state_sent) { - rc = libssh2_packet_require(session, SSH_MSG_KEX_DH_GEX_GROUP, - &key_state->data, &key_state->data_len, - 0, NULL, 0, &key_state->req_state); + rc = _libssh2_packet_require(session, SSH_MSG_KEX_DH_GEX_GROUP, + &key_state->data, &key_state->data_len, + 0, NULL, 0, &key_state->req_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -869,12 +869,12 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange if (key_state->state == libssh2_NB_state_sent1) { s = key_state->data + 1; - p_len = libssh2_ntohu32(s); + p_len = _libssh2_ntohu32(s); s += 4; _libssh2_bn_from_bin(key_state->p, p_len, s); s += p_len; - g_len = libssh2_ntohu32(s); + g_len = _libssh2_ntohu32(s); s += 4; _libssh2_bn_from_bin(key_state->g, g_len, s); s += g_len; @@ -969,7 +969,7 @@ static size_t kex_method_list(unsigned char *buf, size_t list_strlen, LIBSSH2_COMMON_METHOD ** method) { - libssh2_htonu32(buf, list_strlen); + _libssh2_htonu32(buf, list_strlen); buf += 4; if (!method || !*method) { @@ -995,7 +995,7 @@ kex_method_list(unsigned char *buf, size_t list_strlen, #define LIBSSH2_METHOD_PREFS_STR(buf, prefvarlen, prefvar, defaultvar) \ if (prefvar) { \ - libssh2_htonu32((buf), (prefvarlen)); \ + _libssh2_htonu32((buf), (prefvarlen)); \ buf += 4; \ memcpy((buf), (prefvar), (prefvarlen)); \ buf += (prefvarlen); \ @@ -1136,11 +1136,13 @@ static int kexinit(LIBSSH2_SESSION * session) data_len = session->kexinit_data_len; } - if ((rc = libssh2_packet_write(session, data, data_len)) == PACKET_EAGAIN) { + rc = _libssh2_packet_write(session, data, data_len); + if (rc == PACKET_EAGAIN) { session->kexinit_data = data; session->kexinit_data_len = data_len; return PACKET_EAGAIN; - } else if (rc) { + } + else if (rc) { LIBSSH2_FREE(session, data); libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send KEXINIT packet to remote host", 0); @@ -1559,34 +1561,34 @@ static int kex_agree_methods(LIBSSH2_SESSION * session, unsigned char *data, s += 16; /* Locate each string */ - kex_len = libssh2_ntohu32(s); + kex_len = _libssh2_ntohu32(s); kex = s + 4; s += 4 + kex_len; - hostkey_len = libssh2_ntohu32(s); + hostkey_len = _libssh2_ntohu32(s); hostkey = s + 4; s += 4 + hostkey_len; - crypt_cs_len = libssh2_ntohu32(s); + crypt_cs_len = _libssh2_ntohu32(s); crypt_cs = s + 4; s += 4 + crypt_cs_len; - crypt_sc_len = libssh2_ntohu32(s); + crypt_sc_len = _libssh2_ntohu32(s); crypt_sc = s + 4; s += 4 + crypt_sc_len; - mac_cs_len = libssh2_ntohu32(s); + mac_cs_len = _libssh2_ntohu32(s); mac_cs = s + 4; s += 4 + mac_cs_len; - mac_sc_len = libssh2_ntohu32(s); + mac_sc_len = _libssh2_ntohu32(s); mac_sc = s + 4; s += 4 + mac_sc_len; - comp_cs_len = libssh2_ntohu32(s); + comp_cs_len = _libssh2_ntohu32(s); comp_cs = s + 4; s += 4 + comp_cs_len; - comp_sc_len = libssh2_ntohu32(s); + comp_sc_len = _libssh2_ntohu32(s); comp_sc = s + 4; s += 4 + comp_sc_len; - lang_cs_len = libssh2_ntohu32(s); + lang_cs_len = _libssh2_ntohu32(s); lang_cs = s + 4; s += 4 + lang_cs_len; - lang_sc_len = libssh2_ntohu32(s); + lang_sc_len = _libssh2_ntohu32(s); lang_sc = s + 4; s += 4 + lang_sc_len; @@ -1720,14 +1722,15 @@ libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange, if (key_state->state == libssh2_NB_state_sent1) { retcode = - libssh2_packet_require(session, SSH_MSG_KEXINIT, - &key_state->data, - &key_state->data_len, 0, NULL, 0, - &key_state->req_state); + _libssh2_packet_require(session, SSH_MSG_KEXINIT, + &key_state->data, + &key_state->data_len, 0, NULL, 0, + &key_state->req_state); if (retcode == PACKET_EAGAIN) { session->state &= ~LIBSSH2_STATE_KEX_ACTIVE; return PACKET_EAGAIN; - } else if (retcode) { + } + else if (retcode) { if (session->local.kexinit) { LIBSSH2_FREE(session, session->local.kexinit); } diff --git a/src/libssh2_priv.h b/src/libssh2_priv.h index b75a644..0274193 100644 --- a/src/libssh2_priv.h +++ b/src/libssh2_priv.h @@ -159,13 +159,20 @@ static inline int usleep(int udelay) */ #define MAX_SSH_PACKET_LEN 35000 -#define LIBSSH2_ALLOC(session, count) session->alloc((count), &(session)->abstract) -#define LIBSSH2_REALLOC(session, ptr, count) ((ptr) ? session->realloc((ptr), (count), &(session)->abstract) : session->alloc((count), &(session)->abstract)) -#define LIBSSH2_FREE(session, ptr) session->free((ptr), &(session)->abstract) - -#define LIBSSH2_IGNORE(session, data, datalen) session->ssh_msg_ignore((session), (data), (datalen), &(session)->abstract) -#define LIBSSH2_DEBUG(session, always_display, message, message_len, language, language_len) \ - session->ssh_msg_disconnect((session), (always_display), (message), (message_len), (language), (language_len), &(session)->abstract) +#define LIBSSH2_ALLOC(session, count) \ + session->alloc((count), &(session)->abstract) +#define LIBSSH2_REALLOC(session, ptr, count) \ + ((ptr) ? session->realloc((ptr), (count), &(session)->abstract) : \ + session->alloc((count), &(session)->abstract)) +#define LIBSSH2_FREE(session, ptr) \ + session->free((ptr), &(session)->abstract) +#define LIBSSH2_IGNORE(session, data, datalen) \ + session->ssh_msg_ignore((session), (data), (datalen), &(session)->abstract) +#define LIBSSH2_DEBUG(session, always_display, message, message_len, \ + language, language_len) \ + session->ssh_msg_disconnect((session), (always_display), (message), \ + (message_len), (language), (language_len), \ + &(session)->abstract) #define LIBSSH2_DISCONNECT(session, reason, message, message_len, language, language_len) \ session->ssh_msg_disconnect((session), (reason), (message), (message_len), (language), (language_len), &(session)->abstract) @@ -704,7 +711,8 @@ struct _LIBSSH2_SESSION /* (local as source of data -- packet_write ) */ libssh2_endpoint_data local; - /* Inbound Data buffer -- Sometimes the packet that comes in isn't the packet we're ready for */ + /* Inbound Data buffer -- Sometimes the packet that comes in isn't the + packet we're ready for */ LIBSSH2_PACKET_BRIGADE packets; /* Active connection channels */ @@ -866,7 +874,8 @@ struct _LIBSSH2_SESSION libssh2_nonblocking_states sftpInit_state; LIBSSH2_SFTP *sftpInit_sftp; LIBSSH2_CHANNEL *sftpInit_channel; - unsigned char sftpInit_buffer[9]; /* sftp_header(5){excludes request_id} + version_id(4) */ + unsigned char sftpInit_buffer[9]; /* sftp_header(5){excludes request_id} + + version_id(4) */ /* State variables used in libssh2_scp_recv() */ libssh2_nonblocking_states scpRecv_state; @@ -1126,16 +1135,16 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...) #define SSH_MSG_CHANNEL_SUCCESS 99 #define SSH_MSG_CHANNEL_FAILURE 100 -void libssh2_session_shutdown(LIBSSH2_SESSION * session); +void _libssh2_session_shutdown(LIBSSH2_SESSION * session); -unsigned long libssh2_ntohu32(const unsigned char *buf); -libssh2_uint64_t libssh2_ntohu64(const unsigned char *buf); -void libssh2_htonu32(unsigned char *buf, unsigned long val); -void libssh2_htonu64(unsigned char *buf, libssh2_uint64_t val); +unsigned long _libssh2_ntohu32(const unsigned char *buf); +libssh2_uint64_t _libssh2_ntohu64(const unsigned char *buf); +void _libssh2_htonu32(unsigned char *buf, unsigned long val); +void _libssh2_htonu64(unsigned char *buf, libssh2_uint64_t val); #define LIBSSH2_READ_TIMEOUT 60 /* generic timeout in seconds used when waiting for more data to arrive */ -int libssh2_waitsocket(LIBSSH2_SESSION * session, long seconds); +int _libssh2_waitsocket(LIBSSH2_SESSION * session, long seconds); /* CAUTION: some of these error codes are returned in the public API and is @@ -1151,46 +1160,46 @@ int libssh2_waitsocket(LIBSSH2_SESSION * session, long seconds); #define PACKET_FAIL -1 #define PACKET_NONE 0 -libssh2pack_t libssh2_packet_read(LIBSSH2_SESSION * session); +libssh2pack_t _libssh2_packet_read(LIBSSH2_SESSION * session); -int libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type, - unsigned char **data, unsigned long *data_len, - unsigned long match_ofs, - const unsigned char *match_buf, - unsigned long match_len, int poll_socket); - -int libssh2_packet_askv(LIBSSH2_SESSION * session, - const unsigned char *packet_types, +int _libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type, unsigned char **data, unsigned long *data_len, unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len, int poll_socket); -int libssh2_packet_require(LIBSSH2_SESSION * session, - unsigned char packet_type, unsigned char **data, - unsigned long *data_len, unsigned long match_ofs, - const unsigned char *match_buf, - unsigned long match_len, - packet_require_state_t * state); -int libssh2_packet_requirev(LIBSSH2_SESSION * session, - const unsigned char *packet_types, - unsigned char **data, unsigned long *data_len, - unsigned long match_ofs, + +int _libssh2_packet_askv(LIBSSH2_SESSION * session, + const unsigned char *packet_types, + unsigned char **data, unsigned long *data_len, + unsigned long match_ofs, + const unsigned char *match_buf, + unsigned long match_len, int poll_socket); +int _libssh2_packet_require(LIBSSH2_SESSION * session, + unsigned char packet_type, unsigned char **data, + unsigned long *data_len, unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len, - packet_requirev_state_t * state); -int libssh2_packet_burn(LIBSSH2_SESSION * session, - libssh2_nonblocking_states * state); -int libssh2_packet_write(LIBSSH2_SESSION * session, unsigned char *data, - unsigned long data_len); -int libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, - size_t datalen, int macstate); + packet_require_state_t * state); +int _libssh2_packet_requirev(LIBSSH2_SESSION * session, + const unsigned char *packet_types, + unsigned char **data, unsigned long *data_len, + unsigned long match_ofs, + const unsigned char *match_buf, + unsigned long match_len, + packet_requirev_state_t * state); +int _libssh2_packet_burn(LIBSSH2_SESSION * session, + libssh2_nonblocking_states * state); +int _libssh2_packet_write(LIBSSH2_SESSION * session, unsigned char *data, + unsigned long data_len); +int _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, + size_t datalen, int macstate); int libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange, key_exchange_state_t * state); -unsigned long libssh2_channel_nextid(LIBSSH2_SESSION * session); -LIBSSH2_CHANNEL *libssh2_channel_locate(LIBSSH2_SESSION * session, - unsigned long channel_id); -unsigned long libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, - int stream_id); +unsigned long _libssh2_channel_nextid(LIBSSH2_SESSION * session); +LIBSSH2_CHANNEL *_libssh2_channel_locate(LIBSSH2_SESSION * session, + unsigned long channel_id); +unsigned long _libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, + int stream_id); /* this is the lib-internal set blocking function */ int _libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking); diff --git a/src/mac.c b/src/mac.c index 10bd955..447b6c6 100644 --- a/src/mac.c +++ b/src/mac.c @@ -110,7 +110,7 @@ libssh2_mac_method_hmac_sha1_hash(LIBSSH2_SESSION * session, unsigned char seqno_buf[4]; (void) session; - libssh2_htonu32(seqno_buf, seqno); + _libssh2_htonu32(seqno_buf, seqno); libssh2_hmac_sha1_init(&ctx, *abstract, 20); libssh2_hmac_update(ctx, seqno_buf, 4); @@ -181,7 +181,7 @@ libssh2_mac_method_hmac_md5_hash(LIBSSH2_SESSION * session, unsigned char *buf, unsigned char seqno_buf[4]; (void) session; - libssh2_htonu32(seqno_buf, seqno); + _libssh2_htonu32(seqno_buf, seqno); libssh2_hmac_md5_init(&ctx, *abstract, 16); libssh2_hmac_update(ctx, seqno_buf, 4); @@ -254,7 +254,7 @@ libssh2_mac_method_hmac_ripemd160_hash(LIBSSH2_SESSION * session, unsigned char seqno_buf[4]; (void) session; - libssh2_htonu32(seqno_buf, seqno); + _libssh2_htonu32(seqno_buf, seqno); libssh2_hmac_ripemd160_init(&ctx, *abstract, 20); libssh2_hmac_update(ctx, seqno_buf, 4); diff --git a/src/misc.c b/src/misc.c index 13d1f7e..e5c9815 100644 --- a/src/misc.c +++ b/src/misc.c @@ -48,7 +48,7 @@ /* libssh2_ntohu32 */ unsigned long -libssh2_ntohu32(const unsigned char *buf) +_libssh2_ntohu32(const unsigned char *buf) { return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]; } @@ -57,7 +57,7 @@ libssh2_ntohu32(const unsigned char *buf) /* libssh2_ntohu64 */ libssh2_uint64_t -libssh2_ntohu64(const unsigned char *buf) +_libssh2_ntohu64(const unsigned char *buf) { unsigned long msl, lsl; @@ -70,7 +70,7 @@ libssh2_ntohu64(const unsigned char *buf) /* libssh2_htonu32 */ void -libssh2_htonu32(unsigned char *buf, unsigned long value) +_libssh2_htonu32(unsigned char *buf, unsigned long value) { buf[0] = (value >> 24) & 0xFF; buf[1] = (value >> 16) & 0xFF; @@ -81,7 +81,7 @@ libssh2_htonu32(unsigned char *buf, unsigned long value) /* libssh2_htonu64 */ void -libssh2_htonu64(unsigned char *buf, libssh2_uint64_t value) +_libssh2_htonu64(unsigned char *buf, libssh2_uint64_t value) { unsigned long msl = ((libssh2_uint64_t)value >> 32); @@ -98,17 +98,18 @@ libssh2_htonu64(unsigned char *buf, libssh2_uint64_t value) /* Base64 Conversion */ -static const char libssh2_base64_table[] = - { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', +static const char base64_table[] = +{ + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '\0' }; -static const char libssh2_base64_pad = '='; +static const char base64_pad = '='; -static const short libssh2_base64_reverse_table[256] = { +static const short base64_reverse_table[256] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, @@ -147,7 +148,7 @@ libssh2_base64_decode(LIBSSH2_SESSION * session, char **data, } for(s = (unsigned char *) src; ((char *) s) < (src + src_len); s++) { - if ((v = libssh2_base64_reverse_table[*s]) < 0) + if ((v = base64_reverse_table[*s]) < 0) continue; switch (i % 4) { case 0: diff --git a/src/openssl.h b/src/openssl.h index cc7949b..85d70c0 100644 --- a/src/openssl.h +++ b/src/openssl.h @@ -100,8 +100,7 @@ # define LIBSSH2_3DES 1 #endif -#define libssh2_random(buf, len) \ - RAND_bytes ((buf), (len)) +#define libssh2_random(buf, len) RAND_bytes ((buf), (len)) #define libssh2_sha1_ctx SHA_CTX #define libssh2_sha1_init(ctx) SHA1_Init(ctx) diff --git a/src/packet.c b/src/packet.c index 2dd6af4..c50bb78 100644 --- a/src/packet.c +++ b/src/packet.c @@ -1,4 +1,5 @@ /* Copyright (c) 2004-2007, Sara Golemon + * Copyright (c) 2009 by Daniel Stenberg * All rights reserved. * * Redistribution and use in source and binary forms, @@ -58,13 +59,15 @@ #include -/* {{{ libssh2_packet_queue_listener +/* + * libssh2_packet_queue_listener + * * Queue a connection request for a listener */ static inline int -libssh2_packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data, - unsigned long datalen, - packet_queue_listener_state_t * listen_state) +packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data, + unsigned long datalen, + packet_queue_listener_state_t * listen_state) { /* * Look for a matching listener @@ -80,26 +83,26 @@ libssh2_packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data, (void) datalen; if (listen_state->state == libssh2_NB_state_idle) { - listen_state->sender_channel = libssh2_ntohu32(s); + listen_state->sender_channel = _libssh2_ntohu32(s); s += 4; - listen_state->initial_window_size = libssh2_ntohu32(s); + listen_state->initial_window_size = _libssh2_ntohu32(s); s += 4; - listen_state->packet_size = libssh2_ntohu32(s); + listen_state->packet_size = _libssh2_ntohu32(s); s += 4; - listen_state->host_len = libssh2_ntohu32(s); + listen_state->host_len = _libssh2_ntohu32(s); s += 4; listen_state->host = s; s += listen_state->host_len; - listen_state->port = libssh2_ntohu32(s); + listen_state->port = _libssh2_ntohu32(s); s += 4; - listen_state->shost_len = libssh2_ntohu32(s); + listen_state->shost_len = _libssh2_ntohu32(s); s += 4; listen_state->shost = s; s += listen_state->shost_len; - listen_state->sport = libssh2_ntohu32(s); + listen_state->sport = _libssh2_ntohu32(s); s += 4; _libssh2_debug(session, LIBSSH2_DBG_CONN, @@ -169,7 +172,7 @@ libssh2_packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data, channel->remote.packet_size = LIBSSH2_CHANNEL_PACKET_DEFAULT; - channel->local.id = libssh2_channel_nextid(session); + channel->local.id = _libssh2_channel_nextid(session); channel->local.window_size_initial = listen_state->initial_window_size; channel->local.window_size = @@ -186,20 +189,20 @@ libssh2_packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data, p = listen_state->packet; *(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION; - libssh2_htonu32(p, channel->remote.id); + _libssh2_htonu32(p, channel->remote.id); p += 4; - libssh2_htonu32(p, channel->local.id); + _libssh2_htonu32(p, channel->local.id); p += 4; - libssh2_htonu32(p, channel->remote.window_size_initial); + _libssh2_htonu32(p, channel->remote.window_size_initial); p += 4; - libssh2_htonu32(p, channel->remote.packet_size); + _libssh2_htonu32(p, channel->remote.packet_size); p += 4; listen_state->state = libssh2_NB_state_created; } if (listen_state->state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, listen_state->packet, + rc = _libssh2_packet_write(session, listen_state->packet, 17); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; @@ -243,17 +246,17 @@ libssh2_packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data, { p = listen_state->packet; *(p++) = SSH_MSG_CHANNEL_OPEN_FAILURE; - libssh2_htonu32(p, listen_state->sender_channel); + _libssh2_htonu32(p, listen_state->sender_channel); p += 4; - libssh2_htonu32(p, failure_code); + _libssh2_htonu32(p, failure_code); p += 4; - libssh2_htonu32(p, sizeof(FwdNotReq) - 1); + _libssh2_htonu32(p, sizeof(FwdNotReq) - 1); p += 4; memcpy(s, FwdNotReq, sizeof(FwdNotReq) - 1); p += sizeof(FwdNotReq) - 1; - libssh2_htonu32(p, 0); + _libssh2_htonu32(p, 0); - rc = libssh2_packet_write(session, listen_state->packet, packet_len); + rc = _libssh2_packet_write(session, listen_state->packet, packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -267,15 +270,15 @@ libssh2_packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data, } } -/* }}} */ - -/* {{{ libssh2_packet_x11_open +/* + * packet_x11_open + * * Accept a forwarded X11 connection */ static inline int -libssh2_packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data, - unsigned long datalen, - packet_x11_open_state_t * x11open_state) +packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data, + unsigned long datalen, + packet_x11_open_state_t * x11open_state) { int failure_code = 2; /* SSH_OPEN_CONNECT_FAILED */ unsigned char *s = data + (sizeof("x11") - 1) + 5; @@ -288,17 +291,17 @@ libssh2_packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data, (void) datalen; if (x11open_state->state == libssh2_NB_state_idle) { - x11open_state->sender_channel = libssh2_ntohu32(s); + x11open_state->sender_channel = _libssh2_ntohu32(s); s += 4; - x11open_state->initial_window_size = libssh2_ntohu32(s); + x11open_state->initial_window_size = _libssh2_ntohu32(s); s += 4; - x11open_state->packet_size = libssh2_ntohu32(s); + x11open_state->packet_size = _libssh2_ntohu32(s); s += 4; - x11open_state->shost_len = libssh2_ntohu32(s); + x11open_state->shost_len = _libssh2_ntohu32(s); s += 4; x11open_state->shost = s; s += x11open_state->shost_len; - x11open_state->sport = libssh2_ntohu32(s); + x11open_state->sport = _libssh2_ntohu32(s); s += 4; _libssh2_debug(session, LIBSSH2_DBG_CONN, @@ -343,7 +346,7 @@ libssh2_packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data, channel->remote.window_size = LIBSSH2_CHANNEL_WINDOW_DEFAULT; channel->remote.packet_size = LIBSSH2_CHANNEL_PACKET_DEFAULT; - channel->local.id = libssh2_channel_nextid(session); + channel->local.id = _libssh2_channel_nextid(session); channel->local.window_size_initial = x11open_state->initial_window_size; channel->local.window_size = x11open_state->initial_window_size; @@ -358,20 +361,20 @@ libssh2_packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data, channel->remote.packet_size); p = x11open_state->packet; *(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION; - libssh2_htonu32(p, channel->remote.id); + _libssh2_htonu32(p, channel->remote.id); p += 4; - libssh2_htonu32(p, channel->local.id); + _libssh2_htonu32(p, channel->local.id); p += 4; - libssh2_htonu32(p, channel->remote.window_size_initial); + _libssh2_htonu32(p, channel->remote.window_size_initial); p += 4; - libssh2_htonu32(p, channel->remote.packet_size); + _libssh2_htonu32(p, channel->remote.packet_size); p += 4; x11open_state->state = libssh2_NB_state_created; } if (x11open_state->state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, x11open_state->packet, 17); + rc = _libssh2_packet_write(session, x11open_state->packet, 17); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -409,17 +412,17 @@ libssh2_packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data, x11_exit: p = x11open_state->packet; *(p++) = SSH_MSG_CHANNEL_OPEN_FAILURE; - libssh2_htonu32(p, x11open_state->sender_channel); + _libssh2_htonu32(p, x11open_state->sender_channel); p += 4; - libssh2_htonu32(p, failure_code); + _libssh2_htonu32(p, failure_code); p += 4; - libssh2_htonu32(p, sizeof(X11FwdUnAvil) - 1); + _libssh2_htonu32(p, sizeof(X11FwdUnAvil) - 1); p += 4; memcpy(s, X11FwdUnAvil, sizeof(X11FwdUnAvil) - 1); p += sizeof(X11FwdUnAvil) - 1; - libssh2_htonu32(p, 0); + _libssh2_htonu32(p, 0); - rc = libssh2_packet_write(session, x11open_state->packet, packet_len); + rc = _libssh2_packet_write(session, x11open_state->packet, packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -433,14 +436,14 @@ libssh2_packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data, } /* - * libssh2_packet_add + * _libssh2_packet_add * * Create a new packet and attach it to the brigade. Called from the transport * layer when it as received a packet. */ int -libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, - size_t datalen, int macstate) +_libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, + size_t datalen, int macstate) { int rc; @@ -519,11 +522,11 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, char *message, *language; int reason, message_len, language_len; - reason = libssh2_ntohu32(data + 1); - message_len = libssh2_ntohu32(data + 5); + reason = _libssh2_ntohu32(data + 1); + message_len = _libssh2_ntohu32(data + 5); /* 9 = packet_type(1) + reason(4) + message_len(4) */ message = (char *) data + 9; - language_len = libssh2_ntohu32(data + 9 + message_len); + language_len = _libssh2_ntohu32(data + 9 + message_len); /* * This is where we hack on the data a little, * Use the MSB of language_len to to a terminating NULL @@ -574,10 +577,10 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, char *message, *language; int message_len, language_len; - message_len = libssh2_ntohu32(data + 2); + message_len = _libssh2_ntohu32(data + 2); /* 6 = packet_type(1) + display(1) + message_len(4) */ message = (char *) data + 6; - language_len = libssh2_ntohu32(data + 6 + message_len); + language_len = _libssh2_ntohu32(data + 6 + message_len); /* * This is where we hack on the data a little, * Use the MSB of language_len to to a terminating NULL @@ -620,7 +623,7 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, session->packAdd_data_head += 9; session->packAdd_channel = - libssh2_channel_locate(session, libssh2_ntohu32(data + 1)); + _libssh2_channel_locate(session, _libssh2_ntohu32(data + 1)); if (!session->packAdd_channel) { libssh2_error(session, LIBSSH2_ERROR_CHANNEL_UNKNOWN, @@ -634,7 +637,7 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, { unsigned long stream_id = 0; if (data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA) { - stream_id = libssh2_ntohu32(data + 5); + stream_id = _libssh2_ntohu32(data + 5); } _libssh2_debug(session, LIBSSH2_DBG_CONN, @@ -726,9 +729,8 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, case SSH_MSG_CHANNEL_EOF: { - session->packAdd_channel = libssh2_channel_locate(session, - libssh2_ntohu32 - (data + 1)); + session->packAdd_channel = + _libssh2_channel_locate(session, _libssh2_ntohu32(data + 1)); if (!session->packAdd_channel) { /* We may have freed already, just quietly ignore this... */ @@ -752,18 +754,18 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, case SSH_MSG_CHANNEL_REQUEST: { - if (libssh2_ntohu32(data + 5) == sizeof("exit-status") - 1 + if (_libssh2_ntohu32(data + 5) == sizeof("exit-status") - 1 && !memcmp("exit-status", data + 9, sizeof("exit-status") - 1)) { /* we've got "exit-status" packet. Set the session value */ session->packAdd_channel = - libssh2_channel_locate(session, - libssh2_ntohu32(data + 1)); + _libssh2_channel_locate(session, + _libssh2_ntohu32(data + 1)); if (session->packAdd_channel) { 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, "Exit status %lu received for channel %lu/%lu", session->packAdd_channel->exit_status, @@ -780,9 +782,8 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, case SSH_MSG_CHANNEL_CLOSE: { - session->packAdd_channel = libssh2_channel_locate(session, - libssh2_ntohu32 - (data + 1)); + session->packAdd_channel = + _libssh2_channel_locate(session, _libssh2_ntohu32(data + 1)); if (!session->packAdd_channel) { /* We may have freed already, just quietly ignore this... */ @@ -807,7 +808,7 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, case SSH_MSG_CHANNEL_OPEN: if ((datalen >= (sizeof("forwarded-tcpip") + 4)) && - ((sizeof("forwarded-tcpip") - 1) == libssh2_ntohu32(data + 1)) + ((sizeof("forwarded-tcpip") - 1) == _libssh2_ntohu32(data + 1)) && (memcmp (data + 5, "forwarded-tcpip", @@ -815,9 +816,8 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, libssh2_packet_add_jump_point2: session->packAdd_state = libssh2_NB_state_jump2; - rc = libssh2_packet_queue_listener(session, data, datalen, - &session-> - packAdd_Qlstn_state); + rc = packet_queue_listener(session, data, datalen, + &session->packAdd_Qlstn_state); if (rc == PACKET_EAGAIN) { session->socket_block_directions = LIBSSH2_SESSION_BLOCK_OUTBOUND; @@ -829,13 +829,13 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, return rc; } if ((datalen >= (sizeof("x11") + 4)) && - ((sizeof("x11") - 1) == libssh2_ntohu32(data + 1)) && + ((sizeof("x11") - 1) == _libssh2_ntohu32(data + 1)) && (memcmp(data + 5, "x11", sizeof("x11") - 1) == 0)) { libssh2_packet_add_jump_point3: session->packAdd_state = libssh2_NB_state_jump3; - rc = libssh2_packet_x11_open(session, data, datalen, - &session->packAdd_x11open_state); + rc = packet_x11_open(session, data, datalen, + &session->packAdd_x11open_state); if (rc == PACKET_EAGAIN) { session->socket_block_directions = LIBSSH2_SESSION_BLOCK_OUTBOUND; @@ -850,10 +850,10 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, case SSH_MSG_CHANNEL_WINDOW_ADJUST: { - unsigned long bytestoadd = libssh2_ntohu32(data + 5); - session->packAdd_channel = libssh2_channel_locate(session, - libssh2_ntohu32 - (data + 1)); + unsigned long bytestoadd = _libssh2_ntohu32(data + 5); + session->packAdd_channel = + _libssh2_channel_locate(session, + _libssh2_ntohu32(data + 1)); if (session->packAdd_channel && bytestoadd) { session->packAdd_channel->local.window_size += bytestoadd; @@ -955,16 +955,16 @@ libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, } /* - * libssh2_packet_ask + * _libssh2_packet_ask * * Scan the brigade for a matching packet type, optionally poll the socket for * a packet first */ int -libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type, - unsigned char **data, unsigned long *data_len, - unsigned long match_ofs, const unsigned char *match_buf, - unsigned long match_len, int poll_socket) +_libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type, + unsigned char **data, unsigned long *data_len, + unsigned long match_ofs, const unsigned char *match_buf, + unsigned long match_len, int poll_socket) { LIBSSH2_PACKET *packet = session->packets.head; @@ -975,7 +975,7 @@ libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type, * PACKET_EAGAIN. I am not sure what should happen, but internally * there is only one location that might do so, libssh2_packet_askv_ex() */ - libssh2pack_t rc = libssh2_packet_read(session); + libssh2pack_t rc = _libssh2_packet_read(session); if ((rc < 0) && !packet) { return rc; } @@ -1025,12 +1025,12 @@ libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type, * socket for a packet first */ int -libssh2_packet_askv(LIBSSH2_SESSION * session, - const unsigned char *packet_types, - unsigned char **data, unsigned long *data_len, - unsigned long match_ofs, - const unsigned char *match_buf, - unsigned long match_len, int poll_socket) +_libssh2_packet_askv(LIBSSH2_SESSION * session, + const unsigned char *packet_types, + unsigned char **data, unsigned long *data_len, + unsigned long match_ofs, + const unsigned char *match_buf, + unsigned long match_len, int poll_socket) { int i, packet_types_len = strlen((char *) packet_types); @@ -1041,7 +1041,7 @@ libssh2_packet_askv(LIBSSH2_SESSION * session, * return PACKET_EAGAIN. Not sure the correct action, I * think it is right as is. */ - if (0 == libssh2_packet_ask(session, packet_types[i], data, + if (0 == _libssh2_packet_ask(session, packet_types[i], data, data_len, match_ofs, match_buf, match_len, i ? 0 : poll_socket)) { return 0; @@ -1052,7 +1052,7 @@ libssh2_packet_askv(LIBSSH2_SESSION * session, } /* - * libssh2_waitsocket + * _libssh2_waitsocket * * Returns * negative on error @@ -1062,7 +1062,7 @@ libssh2_packet_askv(LIBSSH2_SESSION * session, * FIXME: convert to use poll on systems that have it. */ int -libssh2_waitsocket(LIBSSH2_SESSION * session, long seconds) +_libssh2_waitsocket(LIBSSH2_SESSION * session, long seconds) { struct timeval timeout; int rc; @@ -1081,24 +1081,24 @@ libssh2_waitsocket(LIBSSH2_SESSION * session, long seconds) } /* - * libssh2_packet_require + * _libssh2_packet_require * - * Loops libssh2_packet_read() until the packet requested is available + * Loops _libssh2_packet_read() until the packet requested is available * SSH_DISCONNECT or a SOCKET_DISCONNECTED will cause a bailout * * Returns negative on error * Returns 0 when it has taken care of the requested packet. */ int -libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type, - unsigned char **data, unsigned long *data_len, - unsigned long match_ofs, - const unsigned char *match_buf, - unsigned long match_len, - packet_require_state_t * state) +_libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type, + unsigned char **data, unsigned long *data_len, + unsigned long match_ofs, + const unsigned char *match_buf, + unsigned long match_len, + packet_require_state_t * state) { if (state->start == 0) { - if (libssh2_packet_ask(session, packet_type, data, data_len, + if (_libssh2_packet_ask(session, packet_type, data, data_len, match_ofs, match_buf, match_len, 0) == 0) { /* A packet was available in the packet brigade */ @@ -1113,7 +1113,7 @@ libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type, } while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) { - libssh2pack_t ret = libssh2_packet_read(session); + libssh2pack_t ret = _libssh2_packet_read(session); if (ret == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if ((ret == 0) && (!session->socket_block)) { @@ -1125,7 +1125,7 @@ libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type, return ret; } else if (ret == packet_type) { /* Be lazy, let packet_ask pull it out of the brigade */ - ret = libssh2_packet_ask(session, packet_type, data, data_len, + ret = _libssh2_packet_ask(session, packet_type, data, data_len, match_ofs, match_buf, match_len, 0); state->start = 0; return ret; @@ -1133,7 +1133,7 @@ libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type, /* nothing available, wait until data arrives or we time out */ long left = LIBSSH2_READ_TIMEOUT - (time(NULL) - state->start); - if ((left <= 0) || (libssh2_waitsocket(session, left) <= 0)) { + if ((left <= 0) || (_libssh2_waitsocket(session, left) <= 0)) { state->start = 0; return PACKET_TIMEOUT; } @@ -1144,16 +1144,16 @@ libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type, return -1; } -/* }}} */ - -/* {{{ libssh2_packet_burn - * Loops libssh2_packet_read() until any packet is available and promptly +/* + * libssh2_packet_burn + * + * Loops _libssh2_packet_read() until any packet is available and promptly * discards it * Used during KEX exchange to discard badly guessed KEX_INIT packets */ int -libssh2_packet_burn(LIBSSH2_SESSION * session, - libssh2_nonblocking_states * state) +_libssh2_packet_burn(LIBSSH2_SESSION * session, + libssh2_nonblocking_states * state) { unsigned char *data; unsigned long data_len; @@ -1166,7 +1166,7 @@ libssh2_packet_burn(LIBSSH2_SESSION * session, all_packets[i - 1] = i; } - if (libssh2_packet_askv(session, all_packets, &data, &data_len, 0, + if (_libssh2_packet_askv(session, all_packets, &data, &data_len, 0, NULL, 0, 0) == 0) { i = data[0]; /* A packet was available in the packet brigade, burn it */ @@ -1180,7 +1180,7 @@ libssh2_packet_burn(LIBSSH2_SESSION * session, } while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) { - if ((ret = libssh2_packet_read(session)) == PACKET_EAGAIN) { + if ((ret = _libssh2_packet_read(session)) == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (ret < 0) { *state = libssh2_NB_state_idle; @@ -1192,7 +1192,7 @@ libssh2_packet_burn(LIBSSH2_SESSION * session, /* Be lazy, let packet_ask pull it out of the brigade */ if (0 == - libssh2_packet_ask(session, ret, &data, &data_len, 0, NULL, 0, 0)) { + _libssh2_packet_ask(session, ret, &data, &data_len, 0, NULL, 0, 0)) { /* Smoke 'em if you got 'em */ LIBSSH2_FREE(session, data); *state = libssh2_NB_state_idle; @@ -1205,24 +1205,24 @@ libssh2_packet_burn(LIBSSH2_SESSION * session, } /* - * libssh2_packet_requirev + * _libssh2_packet_requirev * - * Loops libssh2_packet_read() until one of a list of packet types requested is + * Loops _libssh2_packet_read() until one of a list of packet types requested is * available * SSH_DISCONNECT or a SOCKET_DISCONNECTED will cause a bailout * packet_types is a null terminated list of packet_type numbers */ int -libssh2_packet_requirev(LIBSSH2_SESSION * session, - const unsigned char *packet_types, - unsigned char **data, unsigned long *data_len, - unsigned long match_ofs, - const unsigned char *match_buf, - unsigned long match_len, - packet_requirev_state_t * state) +_libssh2_packet_requirev(LIBSSH2_SESSION * session, + const unsigned char *packet_types, + unsigned char **data, unsigned long *data_len, + unsigned long match_ofs, + const unsigned char *match_buf, + unsigned long match_len, + packet_requirev_state_t * state) { - if (libssh2_packet_askv(session, packet_types, data, data_len, match_ofs, + if (_libssh2_packet_askv(session, packet_types, data, data_len, match_ofs, match_buf, match_len, 0) == 0) { /* One of the packets listed was available in the packet brigade */ @@ -1235,7 +1235,7 @@ libssh2_packet_requirev(LIBSSH2_SESSION * session, } while (session->socket_state != LIBSSH2_SOCKET_DISCONNECTED) { - int ret = libssh2_packet_read(session); + int ret = _libssh2_packet_read(session); if ((ret < 0) && (ret != PACKET_EAGAIN)) { state->start = 0; return ret; @@ -1243,7 +1243,7 @@ libssh2_packet_requirev(LIBSSH2_SESSION * session, if (ret <= 0) { long left = LIBSSH2_READ_TIMEOUT - (time(NULL) - state->start); - if ((left <= 0) || (libssh2_waitsocket(session, left) <= 0)) { + if ((left <= 0) || (_libssh2_waitsocket(session, left) <= 0)) { state->start = 0; return PACKET_TIMEOUT; } else if (ret == PACKET_EAGAIN) { @@ -1253,7 +1253,7 @@ libssh2_packet_requirev(LIBSSH2_SESSION * session, if (strchr((char *) packet_types, ret)) { /* Be lazy, let packet_ask pull it out of the brigade */ - return libssh2_packet_askv(session, packet_types, data, + return _libssh2_packet_askv(session, packet_types, data, data_len, match_ofs, match_buf, match_len, 0); } diff --git a/src/publickey.c b/src/publickey.c index 96b9694..5a6fa2a 100644 --- a/src/publickey.c +++ b/src/publickey.c @@ -52,13 +52,12 @@ typedef struct _LIBSSH2_PUBLICKEY_CODE_LIST int name_len; } LIBSSH2_PUBLICKEY_CODE_LIST; -static const LIBSSH2_PUBLICKEY_CODE_LIST libssh2_publickey_response_codes[] = { - {LIBSSH2_PUBLICKEY_RESPONSE_STATUS, "status", sizeof("status") - 1} - , - {LIBSSH2_PUBLICKEY_RESPONSE_VERSION, "version", sizeof("version") - 1} - , - {LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY, "publickey", sizeof("publickey") - 1} - , +static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_response_codes[] = +{ + {LIBSSH2_PUBLICKEY_RESPONSE_STATUS, "status", sizeof("status") - 1}, + {LIBSSH2_PUBLICKEY_RESPONSE_VERSION, "version", sizeof("version") - 1}, + {LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY, "publickey", + sizeof("publickey") - 1} , {0, NULL, 0} }; @@ -75,46 +74,39 @@ static const LIBSSH2_PUBLICKEY_CODE_LIST libssh2_publickey_response_codes[] = { #define LIBSSH2_PUBLICKEY_STATUS_CODE_MAX 8 -static const LIBSSH2_PUBLICKEY_CODE_LIST libssh2_publickey_status_codes[] = { - {LIBSSH2_PUBLICKEY_SUCCESS, "success", sizeof("success") - 1} - , +static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_status_codes[] = { + {LIBSSH2_PUBLICKEY_SUCCESS, "success", sizeof("success") - 1} , {LIBSSH2_PUBLICKEY_ACCESS_DENIED, "access denied", - sizeof("access denied") - 1} - , + sizeof("access denied") - 1}, {LIBSSH2_PUBLICKEY_STORAGE_EXCEEDED, "storage exceeded", - sizeof("storage exceeded") - 1} - , + sizeof("storage exceeded") - 1} , {LIBSSH2_PUBLICKEY_VERSION_NOT_SUPPORTED, "version not supported", - sizeof("version not supported") - 1} - , + sizeof("version not supported") - 1} , {LIBSSH2_PUBLICKEY_KEY_NOT_FOUND, "key not found", - sizeof("key not found") - 1} - , + sizeof("key not found") - 1}, {LIBSSH2_PUBLICKEY_KEY_NOT_SUPPORTED, "key not supported", - sizeof("key not supported") - 1} - , + sizeof("key not supported") - 1}, {LIBSSH2_PUBLICKEY_KEY_ALREADY_PRESENT, "key already present", - sizeof("key already present") - 1} - , + sizeof("key already present") - 1}, {LIBSSH2_PUBLICKEY_GENERAL_FAILURE, "general failure", - sizeof("general failure") - 1} - , + sizeof("general failure") - 1}, {LIBSSH2_PUBLICKEY_REQUEST_NOT_SUPPORTED, "request not supported", - sizeof("request not supported") - 1} - , + sizeof("request not supported") - 1}, {0, NULL, 0} }; -/* {{{ libssh2_publickey_status_error +/* + * publickey_status_error + * * Format an error message from a status code */ #define LIBSSH2_PUBLICKEY_STATUS_TEXT_START "Publickey Subsystem Error: \"" #define LIBSSH2_PUBLICKEY_STATUS_TEXT_MID "\" Server Reports: \"" #define LIBSSH2_PUBLICKEY_STATUS_TEXT_END "\"" static void -libssh2_publickey_status_error(const LIBSSH2_PUBLICKEY * pkey, - LIBSSH2_SESSION * session, int status, - const unsigned char *message, int message_len) +publickey_status_error(const LIBSSH2_PUBLICKEY * pkey, + LIBSSH2_SESSION * session, int status, + const unsigned char *message, int message_len) { const char *status_text; int status_text_len; @@ -130,8 +122,8 @@ libssh2_publickey_status_error(const LIBSSH2_PUBLICKEY * pkey, status_text = "unknown"; status_text_len = sizeof("unknown") - 1; } else { - status_text = libssh2_publickey_status_codes[status].name; - status_text_len = libssh2_publickey_status_codes[status].name_len; + status_text = publickey_status_codes[status].name; + status_text_len = publickey_status_codes[status].name_len; } m_len = @@ -161,14 +153,14 @@ libssh2_publickey_status_error(const LIBSSH2_PUBLICKEY * pkey, libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, m, 1); } -/* }}} */ - -/* {{{ libssh2_publickey_packet_receive +/* + * publickey_packet_receive + * * Read a packet from the subsystem */ static int -libssh2_publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey, - unsigned char **data, unsigned long *data_len) +publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey, + unsigned char **data, unsigned long *data_len) { LIBSSH2_CHANNEL *channel = pkey->channel; LIBSSH2_SESSION *session = channel->session; @@ -185,7 +177,7 @@ libssh2_publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey, return -1; } - pkey->receive_packet_len = libssh2_ntohu32(buffer); + pkey->receive_packet_len = _libssh2_ntohu32(buffer); pkey->receive_packet = LIBSSH2_ALLOC(session, pkey->receive_packet_len); if (!pkey->receive_packet) { @@ -221,25 +213,23 @@ libssh2_publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey, return 0; } -/* }}} */ - -/* {{{ libssh2_publickey_response_id +/* publickey_response_id + * * Translate a string response name to a numeric code * Data will be incremented by 4 + response_len on success only */ static int -libssh2_publickey_response_id(unsigned char **pdata, int data_len) +publickey_response_id(unsigned char **pdata, int data_len) { unsigned long response_len; unsigned char *data = *pdata; - const LIBSSH2_PUBLICKEY_CODE_LIST *codes = - libssh2_publickey_response_codes; + const LIBSSH2_PUBLICKEY_CODE_LIST *codes = publickey_response_codes; if (data_len < 4) { /* Malformed response */ return -1; } - response_len = libssh2_ntohu32(data); + response_len = _libssh2_ntohu32(data); data += 4; data_len -= 4; if (data_len < (int)response_len) { @@ -259,13 +249,12 @@ libssh2_publickey_response_id(unsigned char **pdata, int data_len) return -1; } -/* }}} */ - -/* {{{ libssh2_publickey_response_success +/* libssh2_publickey_response_success + * * Generic helper routine to wait for success response and nothing else */ static int -libssh2_publickey_response_success(LIBSSH2_PUBLICKEY * pkey) +publickey_response_success(LIBSSH2_PUBLICKEY * pkey) { LIBSSH2_SESSION *session = pkey->channel->session; unsigned char *data, *s; @@ -274,7 +263,7 @@ libssh2_publickey_response_success(LIBSSH2_PUBLICKEY * pkey) int rc; while (1) { - rc = libssh2_publickey_packet_receive(pkey, &data, &data_len); + rc = publickey_packet_receive(pkey, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -285,7 +274,7 @@ libssh2_publickey_response_success(LIBSSH2_PUBLICKEY * pkey) } s = data; - if ((response = libssh2_publickey_response_id(&s, data_len)) < 0) { + if ((response = publickey_response_id(&s, data_len)) < 0) { libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, "Invalid publickey subsystem response code", 0); LIBSSH2_FREE(session, data); @@ -299,13 +288,13 @@ libssh2_publickey_response_success(LIBSSH2_PUBLICKEY * pkey) unsigned long status, descr_len, lang_len; unsigned char *descr, *lang; - status = libssh2_ntohu32(s); + status = _libssh2_ntohu32(s); s += 4; - descr_len = libssh2_ntohu32(s); + descr_len = _libssh2_ntohu32(s); s += 4; descr = s; s += descr_len; - lang_len = libssh2_ntohu32(s); + lang_len = _libssh2_ntohu32(s); s += 4; lang = s; s += lang_len; @@ -322,8 +311,8 @@ libssh2_publickey_response_success(LIBSSH2_PUBLICKEY * pkey) return 0; } - libssh2_publickey_status_error(pkey, session, status, descr, - descr_len); + publickey_status_error(pkey, session, status, descr, + descr_len); LIBSSH2_FREE(session, data); return -1; } @@ -340,14 +329,13 @@ libssh2_publickey_response_success(LIBSSH2_PUBLICKEY * pkey) return -1; } -/* }}} */ - - /* ***************** * Publickey API * ***************** */ -/* {{{ libssh2_publickey_init +/* + * libssh2_publickey_init + * * Startup the publickey subsystem */ LIBSSH2_API LIBSSH2_PUBLICKEY * @@ -436,13 +424,13 @@ libssh2_publickey_init(LIBSSH2_SESSION * session) session->pkeyInit_pkey->version = 0; s = buffer; - libssh2_htonu32(s, 4 + (sizeof("version") - 1) + 4); + _libssh2_htonu32(s, 4 + (sizeof("version") - 1) + 4); s += 4; - libssh2_htonu32(s, sizeof("version") - 1); + _libssh2_htonu32(s, sizeof("version") - 1); s += 4; memcpy(s, "version", sizeof("version") - 1); s += sizeof("version") - 1; - libssh2_htonu32(s, LIBSSH2_PUBLICKEY_VERSION); + _libssh2_htonu32(s, LIBSSH2_PUBLICKEY_VERSION); s += 4; _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, @@ -470,9 +458,9 @@ libssh2_publickey_init(LIBSSH2_SESSION * session) if (session->pkeyInit_state == libssh2_NB_state_sent3) { while (1) { - rc = libssh2_publickey_packet_receive(session->pkeyInit_pkey, - &session->pkeyInit_data, - &session->pkeyInit_data_len); + rc = publickey_packet_receive(session->pkeyInit_pkey, + &session->pkeyInit_data, + &session->pkeyInit_data_len); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block waiting for response from publickey subsystem", @@ -487,9 +475,7 @@ libssh2_publickey_init(LIBSSH2_SESSION * session) s = session->pkeyInit_data; if ((response = - libssh2_publickey_response_id(&s, - session->pkeyInit_data_len)) < - 0) { + publickey_response_id(&s, session->pkeyInit_data_len)) < 0) { libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, "Invalid publickey subsystem response code", 0); goto err_exit; @@ -502,13 +488,13 @@ libssh2_publickey_init(LIBSSH2_SESSION * session) unsigned long status, descr_len, lang_len; unsigned char *descr, *lang; - status = libssh2_ntohu32(s); + status = _libssh2_ntohu32(s); s += 4; - descr_len = libssh2_ntohu32(s); + descr_len = _libssh2_ntohu32(s); s += 4; descr = s; s += descr_len; - lang_len = libssh2_ntohu32(s); + lang_len = _libssh2_ntohu32(s); s += 4; lang = s; s += lang_len; @@ -522,14 +508,14 @@ libssh2_publickey_init(LIBSSH2_SESSION * session) goto err_exit; } - libssh2_publickey_status_error(NULL, session, status, - descr, descr_len); + publickey_status_error(NULL, session, status, + descr, descr_len); goto err_exit; } case LIBSSH2_PUBLICKEY_RESPONSE_VERSION: /* What we want */ - session->pkeyInit_pkey->version = libssh2_ntohu32(s); + session->pkeyInit_pkey->version = _libssh2_ntohu32(s); if (session->pkeyInit_pkey->version > LIBSSH2_PUBLICKEY_VERSION) { _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, @@ -580,9 +566,9 @@ libssh2_publickey_init(LIBSSH2_SESSION * session) return NULL; } -/* }}} */ - -/* {{{ libssh2_publickey_add_ex +/* + * libssh2_publickey_add_ex + * * Add a new public key entry */ LIBSSH2_API int @@ -635,48 +621,48 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY * pkey, const unsigned char *name, } pkey->add_s = pkey->add_packet; - libssh2_htonu32(pkey->add_s, packet_len - 4); + _libssh2_htonu32(pkey->add_s, packet_len - 4); pkey->add_s += 4; - libssh2_htonu32(pkey->add_s, sizeof("add") - 1); + _libssh2_htonu32(pkey->add_s, sizeof("add") - 1); pkey->add_s += 4; memcpy(pkey->add_s, "add", sizeof("add") - 1); pkey->add_s += sizeof("add") - 1; if (pkey->version == 1) { - libssh2_htonu32(pkey->add_s, comment_len); + _libssh2_htonu32(pkey->add_s, comment_len); pkey->add_s += 4; if (comment) { memcpy(pkey->add_s, comment, comment_len); pkey->add_s += comment_len; } - libssh2_htonu32(pkey->add_s, name_len); + _libssh2_htonu32(pkey->add_s, name_len); pkey->add_s += 4; memcpy(pkey->add_s, name, name_len); pkey->add_s += name_len; - libssh2_htonu32(pkey->add_s, blob_len); + _libssh2_htonu32(pkey->add_s, blob_len); pkey->add_s += 4; memcpy(pkey->add_s, blob, blob_len); pkey->add_s += blob_len; } else { /* Version == 2 */ - libssh2_htonu32(pkey->add_s, name_len); + _libssh2_htonu32(pkey->add_s, name_len); pkey->add_s += 4; memcpy(pkey->add_s, name, name_len); pkey->add_s += name_len; - libssh2_htonu32(pkey->add_s, blob_len); + _libssh2_htonu32(pkey->add_s, blob_len); pkey->add_s += 4; memcpy(pkey->add_s, blob, blob_len); pkey->add_s += blob_len; *(pkey->add_s++) = overwrite ? 0x01 : 0; - libssh2_htonu32(pkey->add_s, num_attrs); + _libssh2_htonu32(pkey->add_s, num_attrs); pkey->add_s += 4; for(i = 0; i < num_attrs; i++) { - libssh2_htonu32(pkey->add_s, attrs[i].name_len); + _libssh2_htonu32(pkey->add_s, attrs[i].name_len); pkey->add_s += 4; memcpy(pkey->add_s, attrs[i].name, attrs[i].name_len); pkey->add_s += attrs[i].name_len; - libssh2_htonu32(pkey->add_s, attrs[i].value_len); + _libssh2_htonu32(pkey->add_s, attrs[i].value_len); pkey->add_s += 4; memcpy(pkey->add_s, attrs[i].value, attrs[i].value_len); pkey->add_s += attrs[i].value_len; @@ -709,7 +695,7 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY * pkey, const unsigned char *name, pkey->add_state = libssh2_NB_state_sent; } - rc = libssh2_publickey_response_success(pkey); + rc = publickey_response_success(pkey); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } @@ -719,9 +705,7 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY * pkey, const unsigned char *name, return rc; } -/* }}} */ - -/* {{{ libssh2_publickey_remove_ex +/* libssh2_publickey_remove_ex * Remove an existing publickey so that authentication can no longer be performed using it */ LIBSSH2_API int @@ -747,17 +731,17 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey, } pkey->remove_s = pkey->remove_packet; - libssh2_htonu32(pkey->remove_s, packet_len - 4); + _libssh2_htonu32(pkey->remove_s, packet_len - 4); pkey->remove_s += 4; - libssh2_htonu32(pkey->remove_s, sizeof("remove") - 1); + _libssh2_htonu32(pkey->remove_s, sizeof("remove") - 1); pkey->remove_s += 4; memcpy(pkey->remove_s, "remove", sizeof("remove") - 1); pkey->remove_s += sizeof("remove") - 1; - libssh2_htonu32(pkey->remove_s, name_len); + _libssh2_htonu32(pkey->remove_s, name_len); pkey->remove_s += 4; memcpy(pkey->remove_s, name, name_len); pkey->remove_s += name_len; - libssh2_htonu32(pkey->remove_s, blob_len); + _libssh2_htonu32(pkey->remove_s, blob_len); pkey->remove_s += 4; memcpy(pkey->remove_s, blob, blob_len); pkey->remove_s += blob_len; @@ -788,7 +772,7 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey, pkey->remove_state = libssh2_NB_state_sent; } - rc = libssh2_publickey_response_success(pkey); + rc = publickey_response_success(pkey); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } @@ -798,9 +782,7 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey, return rc; } -/* }}} */ - -/* {{{ libssh2_publickey_list_fetch +/* libssh2_publickey_list_fetch * Fetch a list of supported public key from a server */ LIBSSH2_API int @@ -819,9 +801,9 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys, pkey->listFetch_data = NULL; pkey->listFetch_s = pkey->listFetch_buffer; - libssh2_htonu32(pkey->listFetch_s, buffer_len - 4); + _libssh2_htonu32(pkey->listFetch_s, buffer_len - 4); pkey->listFetch_s += 4; - libssh2_htonu32(pkey->listFetch_s, sizeof("list") - 1); + _libssh2_htonu32(pkey->listFetch_s, sizeof("list") - 1); pkey->listFetch_s += 4; memcpy(pkey->listFetch_s, "list", sizeof("list") - 1); pkey->listFetch_s += sizeof("list") - 1; @@ -850,8 +832,8 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys, } while (1) { - rc = libssh2_publickey_packet_receive(pkey, &pkey->listFetch_data, - &pkey->listFetch_data_len); + rc = publickey_packet_receive(pkey, &pkey->listFetch_data, + &pkey->listFetch_data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -863,8 +845,8 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys, pkey->listFetch_s = pkey->listFetch_data; if ((response = - libssh2_publickey_response_id(&pkey->listFetch_s, - pkey->listFetch_data_len)) < 0) { + publickey_response_id(&pkey->listFetch_s, + pkey->listFetch_data_len)) < 0) { libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, "Invalid publickey subsystem response code", 0); goto err_exit; @@ -877,13 +859,13 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys, unsigned long status, descr_len, lang_len; unsigned char *descr, *lang; - status = libssh2_ntohu32(pkey->listFetch_s); + status = _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; - descr_len = libssh2_ntohu32(pkey->listFetch_s); + descr_len = _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; descr = pkey->listFetch_s; pkey->listFetch_s += descr_len; - lang_len = libssh2_ntohu32(pkey->listFetch_s); + lang_len = _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; lang = pkey->listFetch_s; pkey->listFetch_s += lang_len; @@ -904,8 +886,8 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys, return 0; } - libssh2_publickey_status_error(pkey, session, status, descr, - descr_len); + publickey_status_error(pkey, session, status, descr, + descr_len); goto err_exit; } case LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY: @@ -929,7 +911,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys, if (pkey->version == 1) { unsigned long comment_len; - comment_len = libssh2_ntohu32(pkey->listFetch_s); + comment_len = _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; if (comment_len) { list[keys].num_attrs = 1; @@ -953,25 +935,25 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys, list[keys].num_attrs = 0; list[keys].attrs = NULL; } - list[keys].name_len = libssh2_ntohu32(pkey->listFetch_s); + list[keys].name_len = _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; list[keys].name = pkey->listFetch_s; pkey->listFetch_s += list[keys].name_len; - list[keys].blob_len = libssh2_ntohu32(pkey->listFetch_s); + list[keys].blob_len = _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; list[keys].blob = pkey->listFetch_s; pkey->listFetch_s += list[keys].blob_len; } else { /* Version == 2 */ - list[keys].name_len = libssh2_ntohu32(pkey->listFetch_s); + list[keys].name_len = _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; list[keys].name = pkey->listFetch_s; pkey->listFetch_s += list[keys].name_len; - list[keys].blob_len = libssh2_ntohu32(pkey->listFetch_s); + list[keys].blob_len = _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; list[keys].blob = pkey->listFetch_s; pkey->listFetch_s += list[keys].blob_len; - list[keys].num_attrs = libssh2_ntohu32(pkey->listFetch_s); + list[keys].num_attrs = _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; if (list[keys].num_attrs) { list[keys].attrs = @@ -986,12 +968,12 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys, } for(i = 0; i < list[keys].num_attrs; i++) { list[keys].attrs[i].name_len = - libssh2_ntohu32(pkey->listFetch_s); + _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; list[keys].attrs[i].name = (char *) pkey->listFetch_s; pkey->listFetch_s += list[keys].attrs[i].name_len; list[keys].attrs[i].value_len = - libssh2_ntohu32(pkey->listFetch_s); + _libssh2_ntohu32(pkey->listFetch_s); pkey->listFetch_s += 4; list[keys].attrs[i].value = (char *) pkey->listFetch_s; pkey->listFetch_s += list[keys].attrs[i].value_len; @@ -1030,9 +1012,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys, return -1; } -/* }}} */ - -/* {{{ libssh2_publickey_list_free +/* libssh2_publickey_list_free * Free a previously fetched list of public keys */ LIBSSH2_API void @@ -1053,9 +1033,7 @@ libssh2_publickey_list_free(LIBSSH2_PUBLICKEY * pkey, LIBSSH2_FREE(session, pkey_list); } -/* }}} */ - -/* {{{ libssh2_publickey_shutdown +/* libssh2_publickey_shutdown * Shutdown the publickey subsystem */ LIBSSH2_API int @@ -1090,5 +1068,3 @@ libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY * pkey) LIBSSH2_FREE(session, pkey); return 0; } - -/* }}} */ diff --git a/src/scp.c b/src/scp.c index d8b7db1..05ff4ca 100644 --- a/src/scp.c +++ b/src/scp.c @@ -404,8 +404,8 @@ libssh2_scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb) 0); session->scpRecv_err_len = - libssh2_channel_packet_data_len(session-> - scpRecv_channel, 0); + _libssh2_channel_packet_data_len(session-> + scpRecv_channel, 0); session->scpRecv_err_msg = LIBSSH2_ALLOC(session, session->scpRecv_err_len + 1); if (!session->scpRecv_err_msg) { @@ -981,7 +981,7 @@ libssh2_scp_send_ex(LIBSSH2_SESSION * session, const char *path, int mode, "Invalid ACK response from remote", 0); session->scpSend_err_len = - libssh2_channel_packet_data_len(session->scpSend_channel, 0); + _libssh2_channel_packet_data_len(session->scpSend_channel, 0); session->scpSend_err_msg = LIBSSH2_ALLOC(session, session->scpSend_err_len + 1); if (!session->scpSend_err_msg) { diff --git a/src/session.c b/src/session.c index 67b1588..4fafb0c 100644 --- a/src/session.c +++ b/src/session.c @@ -50,7 +50,7 @@ #include #endif -/* {{{ libssh2_default_alloc +/* libssh2_default_alloc */ static LIBSSH2_ALLOC_FUNC(libssh2_default_alloc) @@ -59,9 +59,7 @@ LIBSSH2_ALLOC_FUNC(libssh2_default_alloc) return malloc(count); } -/* }}} */ - -/* {{{ libssh2_default_free +/* libssh2_default_free */ static LIBSSH2_FREE_FUNC(libssh2_default_free) @@ -70,9 +68,7 @@ LIBSSH2_FREE_FUNC(libssh2_default_free) free(ptr); } -/* }}} */ - -/* {{{ libssh2_default_realloc +/* libssh2_default_realloc */ static LIBSSH2_REALLOC_FUNC(libssh2_default_realloc) @@ -81,15 +77,15 @@ LIBSSH2_REALLOC_FUNC(libssh2_default_realloc) return realloc(ptr, count); } -/* }}} */ - -/* {{{ libssh2_banner_receive +/* + * banner_receive + * * Wait for a hello from the remote host * Allocate a buffer and store the banner in session->remote.banner * Returns: 0 on success, PACKET_EAGAIN if read would block, 1 on failure */ static int -libssh2_banner_receive(LIBSSH2_SESSION * session) +banner_receive(LIBSSH2_SESSION * session) { int ret; int banner_len; @@ -186,9 +182,9 @@ libssh2_banner_receive(LIBSSH2_SESSION * session) return 0; } -/* }}} */ - -/* {{{ libssh2_banner_send +/* + * banner_send + * * Send the default banner, or the one set via libssh2_setopt_string * * Returns PACKET_EAGAIN if it would block - and if it does so, you should @@ -197,7 +193,7 @@ libssh2_banner_receive(LIBSSH2_SESSION * session) * (same data pointer and same data_len) until zero or failure is returned. */ static int -libssh2_banner_send(LIBSSH2_SESSION * session) +banner_send(LIBSSH2_SESSION * session) { char *banner = (char *) LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF; int banner_len = sizeof(LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF) - 1; @@ -254,16 +250,14 @@ libssh2_banner_send(LIBSSH2_SESSION * session) return 0; } -/* }}} */ - /* - * _libssh2_nonblock() sets the given socket to either blocking or + * session_nonblock() sets the given socket to either blocking or * non-blocking mode based on the 'nonblock' boolean argument. This function * is copied from the libcurl sources with permission. */ static int -_libssh2_nonblock(int sockfd, /* operate on this */ - int nonblock /* TRUE or FALSE */ ) +session_nonblock(int sockfd, /* operate on this */ + int nonblock /* TRUE or FALSE */ ) { #undef SETBLOCK #define SETBLOCK 0 @@ -327,11 +321,12 @@ _libssh2_nonblock(int sockfd, /* operate on this */ } /* - * _libssh2_get_socket_nonblocking() gets the given blocking or non-blocking - * state of the socket. + * get_socket_nonblocking() + * + * gets the given blocking or non-blocking state of the socket. */ static int -_libssh2_get_socket_nonblocking(int sockfd) +get_socket_nonblocking(int sockfd) { /* operate on this */ #undef GETBLOCK #define GETBLOCK 0 @@ -386,7 +381,7 @@ _libssh2_get_socket_nonblocking(int sockfd) #endif } -/* {{{ libssh2_banner_set +/* libssh2_banner_set * Set the local banner */ LIBSSH2_API int @@ -421,9 +416,9 @@ libssh2_banner_set(LIBSSH2_SESSION * session, const char *banner) return 0; } -/* }}} */ - -/* {{{ proto libssh2_session_init +/* + * proto libssh2_session_init + * * Allocate and initialize a libssh2 session structure * Allows for malloc callbacks in case the calling program has its own memory manager * It's allowable (but unadvisable) to define some but not all of the malloc callbacks @@ -463,9 +458,9 @@ libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)), return session; } -/* }}} */ - -/* {{{ libssh2_session_callback_set +/* + * libssh2_session_callback_set + * * Set (or reset) a callback function * Returns the prior address * @@ -510,9 +505,9 @@ libssh2_session_callback_set(LIBSSH2_SESSION * session, return NULL; } -/* }}} */ - -/* {{{ proto libssh2_session_startup +/* + * proto libssh2_session_startup + * * session: LIBSSH2_SESSION struct allocated and owned by the calling program * Returns: 0 on success, or non-zero on failure * Any memory allocated by libssh2 will use alloc/realloc/free @@ -537,14 +532,14 @@ libssh2_session_startup(LIBSSH2_SESSION * session, int sock) session->socket_fd = sock; session->socket_block = - !_libssh2_get_socket_nonblocking(session->socket_fd); + !get_socket_nonblocking(session->socket_fd); if (session->socket_block) { /* * Since we can't be sure that we are in blocking or there * was an error detecting the state, so set to blocking to * be sure */ - _libssh2_nonblock(session->socket_fd, 0); + session_nonblock(session->socket_fd, 0); } session->startup_state = libssh2_NB_state_created; @@ -553,7 +548,7 @@ libssh2_session_startup(LIBSSH2_SESSION * session, int sock) /* TODO: Liveness check */ if (session->startup_state == libssh2_NB_state_created) { - rc = libssh2_banner_send(session); + rc = banner_send(session); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block sending banner to remote host", 0); @@ -569,7 +564,7 @@ libssh2_session_startup(LIBSSH2_SESSION * session, int sock) } if (session->startup_state == libssh2_NB_state_sent) { - rc = libssh2_banner_receive(session); + rc = banner_receive(session); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block waiting for banner", 0); @@ -605,7 +600,7 @@ libssh2_session_startup(LIBSSH2_SESSION * session, int sock) /* Request the userauth service */ session->startup_service[0] = SSH_MSG_SERVICE_REQUEST; - libssh2_htonu32(session->startup_service + 1, + _libssh2_htonu32(session->startup_service + 1, sizeof("ssh-userauth") - 1); memcpy(session->startup_service + 5, "ssh-userauth", sizeof("ssh-userauth") - 1); @@ -614,13 +609,14 @@ libssh2_session_startup(LIBSSH2_SESSION * session, int sock) } if (session->startup_state == libssh2_NB_state_sent3) { - rc = libssh2_packet_write(session, session->startup_service, - sizeof("ssh-userauth") + 5 - 1); + rc = _libssh2_packet_write(session, session->startup_service, + sizeof("ssh-userauth") + 5 - 1); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block asking for ssh-userauth service", 0); return LIBSSH2_ERROR_EAGAIN; - } else if (rc) { + } + else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to ask for ssh-userauth service", 0); return LIBSSH2_ERROR_SOCKET_SEND; @@ -630,17 +626,17 @@ libssh2_session_startup(LIBSSH2_SESSION * session, int sock) } if (session->startup_state == libssh2_NB_state_sent4) { - rc = libssh2_packet_require(session, SSH_MSG_SERVICE_ACCEPT, - &session->startup_data, - &session->startup_data_len, 0, NULL, 0, - &session->startup_req_state); + rc = _libssh2_packet_require(session, SSH_MSG_SERVICE_ACCEPT, + &session->startup_data, + &session->startup_data_len, 0, NULL, 0, + &session->startup_req_state); if (rc == PACKET_EAGAIN) { return LIBSSH2_ERROR_EAGAIN; } else if (rc) { return LIBSSH2_ERROR_SOCKET_DISCONNECT; } session->startup_service_length = - libssh2_ntohu32(session->startup_data + 1); + _libssh2_ntohu32(session->startup_data + 1); if ((session->startup_service_length != (sizeof("ssh-userauth") - 1)) || strncmp("ssh-userauth", (char *) session->startup_data + 5, @@ -663,9 +659,9 @@ libssh2_session_startup(LIBSSH2_SESSION * session, int sock) return LIBSSH2_ERROR_INVAL; } -/* }}} */ - -/* {{{ proto libssh2_session_free +/* + * libssh2_session_free + * * Frees the memory allocated to the session * Also closes and frees any channels attached to this session */ @@ -699,7 +695,8 @@ libssh2_session_free(LIBSSH2_SESSION * session) /* free */ LIBSSH2_FREE(session, tmp); - /* reverse linking isn't important here, we're killing the structure */ + /* reverse linking isn't important here, we're killing the + * structure */ } } @@ -898,9 +895,7 @@ libssh2_session_free(LIBSSH2_SESSION * session) return 0; } -/* }}} */ - -/* {{{ libssh2_session_disconnect_ex +/* libssh2_session_disconnect_ex */ LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION * session, int reason, @@ -934,17 +929,17 @@ libssh2_session_disconnect_ex(LIBSSH2_SESSION * session, int reason, } *(s++) = SSH_MSG_DISCONNECT; - libssh2_htonu32(s, reason); + _libssh2_htonu32(s, reason); s += 4; - libssh2_htonu32(s, descr_len); + _libssh2_htonu32(s, descr_len); s += 4; if (description) { memcpy(s, description, descr_len); s += descr_len; } - libssh2_htonu32(s, lang_len); + _libssh2_htonu32(s, lang_len); s += 4; if (lang) { memcpy(s, lang, lang_len); @@ -954,8 +949,8 @@ libssh2_session_disconnect_ex(LIBSSH2_SESSION * session, int reason, session->disconnect_state = libssh2_NB_state_created; } - rc = libssh2_packet_write(session, session->disconnect_data, - session->disconnect_data_len); + rc = _libssh2_packet_write(session, session->disconnect_data, + session->disconnect_data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } @@ -967,9 +962,7 @@ libssh2_session_disconnect_ex(LIBSSH2_SESSION * session, int reason, return 0; } -/* }}} */ - -/* {{{ libssh2_session_methods +/* libssh2_session_methods * Return the currently active methods for method_type * NOTE: Currently lang_cs and lang_sc are ALWAYS set to empty string regardless of actual negotiation * Strings should NOT be freed @@ -1037,9 +1030,7 @@ libssh2_session_methods(LIBSSH2_SESSION * session, int method_type) return method->name; } -/* }}} */ - -/* {{{ libssh2_session_abstract +/* libssh2_session_abstract * Retrieve a pointer to the abstract property */ LIBSSH2_API void ** @@ -1048,9 +1039,7 @@ libssh2_session_abstract(LIBSSH2_SESSION * session) return &session->abstract; } -/* }}} */ - -/* {{{ libssh2_session_last_error +/* libssh2_session_last_error * Returns error code and populates an error string into errmsg * If want_buf is non-zero then the string placed into errmsg must be freed by the calling program * Otherwise it is assumed to be owned by libssh2 @@ -1106,9 +1095,7 @@ libssh2_session_last_error(LIBSSH2_SESSION * session, char **errmsg, return session->err_code; } -/* }}} */ - -/* {{{ libssh2_session_last_error +/* libssh2_session_last_error * Returns error code */ LIBSSH2_API int @@ -1117,9 +1104,7 @@ libssh2_session_last_errno(LIBSSH2_SESSION * session) return session->err_code; } -/* }}} */ - -/* {{{ libssh2_session_flag +/* libssh2_session_flag * Set/Get session flags * Passing flag==0 will avoid changing session->flags while still returning its current value */ @@ -1135,9 +1120,8 @@ libssh2_session_flag(LIBSSH2_SESSION * session, int flag, int value) return session->flags; } -/* }}} */ - -/* {{{ _libssh2_session_set_blocking +/* _libssh2_session_set_blocking + * * Set a session's blocking mode on or off, return the previous status * when this function is called. */ @@ -1153,14 +1137,13 @@ _libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking) } session->socket_block = blocking; - _libssh2_nonblock(session->socket_fd, !blocking); + session_nonblock(session->socket_fd, !blocking); return bl; } -/* }}} */ - -/* {{{ libssh2_session_set_blocking +/* libssh2_session_set_blocking + * * Set a channel's blocking mode on or off, similar to a socket's * fcntl(fd, F_SETFL, O_NONBLOCK); type command */ @@ -1170,20 +1153,19 @@ libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking) (void) _libssh2_session_set_blocking(session, blocking); } -/* }}} */ - -/* {{{ libssh2_session_get_blocking -* Returns a session's blocking mode on or off -*/ +/* libssh2_session_get_blocking + * + * Returns a session's blocking mode on or off + */ LIBSSH2_API int libssh2_session_get_blocking(LIBSSH2_SESSION * session) { return session->socket_block; } -/* }}} */ - -/* {{{ libssh2_poll_channel_read +/* + * libssh2_poll_channel_read + * * Returns 0 if no data is waiting on channel, * non-0 if data is available */ @@ -1193,18 +1175,17 @@ libssh2_poll_channel_read(LIBSSH2_CHANNEL * channel, int extended) LIBSSH2_SESSION *session = channel->session; LIBSSH2_PACKET *packet = session->packets.head; - while (packet) - { - if ( channel->local.id == libssh2_ntohu32(packet->data + 1)) { - if ( extended == 1 && - (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA - || packet->data[0] == SSH_MSG_CHANNEL_DATA )) { - return 1; - } else if ( extended == 0 && - packet->data[0] == SSH_MSG_CHANNEL_DATA) { - return 1; - } - /* else - no data of any type is ready to be read */ + while (packet) { + if ( channel->local.id == _libssh2_ntohu32(packet->data + 1)) { + if ( extended == 1 && + (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA + || packet->data[0] == SSH_MSG_CHANNEL_DATA )) { + return 1; + } else if ( extended == 0 && + packet->data[0] == SSH_MSG_CHANNEL_DATA) { + return 1; + } + /* else - no data of any type is ready to be read */ } packet = packet->next; } @@ -1212,33 +1193,32 @@ libssh2_poll_channel_read(LIBSSH2_CHANNEL * channel, int extended) return 0; } -/* }}} */ - -/* {{{ libssh2_poll_channel_write +/* + * poll_channel_write + * * Returns 0 if writing to channel would block, * non-0 if data can be written without blocking */ static inline int -libssh2_poll_channel_write(LIBSSH2_CHANNEL * channel) +poll_channel_write(LIBSSH2_CHANNEL * channel) { return channel->local.window_size ? 1 : 0; } -/* }}} */ - -/* {{{ libssh2_poll_listener_queued +/* poll_listener_queued + * * Returns 0 if no connections are waiting to be accepted * non-0 if one or more connections are available */ static inline int -libssh2_poll_listener_queued(LIBSSH2_LISTENER * listener) +poll_listener_queued(LIBSSH2_LISTENER * listener) { return listener->queue ? 1 : 0; } -/* }}} */ - -/* {{{ libssh2_poll +/* + * libssh2_poll + * * Poll sockets, channels, and listeners for activity */ LIBSSH2_API int @@ -1360,25 +1340,30 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout) if (fds[i].events != fds[i].revents) { switch (fds[i].type) { case LIBSSH2_POLLFD_CHANNEL: - if ((fds[i].events & LIBSSH2_POLLFD_POLLIN) && /* Want to be ready for read */ - ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) { /* Not yet known to be ready for read */ + if ((fds[i].events & LIBSSH2_POLLFD_POLLIN) && + /* Want to be ready for read */ + ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) { + /* Not yet known to be ready for read */ fds[i].revents |= libssh2_poll_channel_read(fds[i].fd.channel, 0) ? LIBSSH2_POLLFD_POLLIN : 0; } - if ((fds[i].events & LIBSSH2_POLLFD_POLLEXT) && /* Want to be ready for extended read */ - ((fds[i].revents & LIBSSH2_POLLFD_POLLEXT) == 0)) { /* Not yet known to be ready for extended read */ + if ((fds[i].events & LIBSSH2_POLLFD_POLLEXT) && + /* Want to be ready for extended read */ + ((fds[i].revents & LIBSSH2_POLLFD_POLLEXT) == 0)) { + /* Not yet known to be ready for extended read */ fds[i].revents |= libssh2_poll_channel_read(fds[i].fd.channel, 1) ? LIBSSH2_POLLFD_POLLEXT : 0; } - if ((fds[i].events & LIBSSH2_POLLFD_POLLOUT) && /* Want to be ready for write */ - ((fds[i].revents & LIBSSH2_POLLFD_POLLOUT) == 0)) { /* Not yet known to be ready for write */ + if ((fds[i].events & LIBSSH2_POLLFD_POLLOUT) && + /* Want to be ready for write */ + ((fds[i].revents & LIBSSH2_POLLFD_POLLOUT) == 0)) { + /* Not yet known to be ready for write */ fds[i].revents |= - libssh2_poll_channel_write(fds[i].fd. - channel) ? + poll_channel_write(fds[i].fd. channel) ? LIBSSH2_POLLFD_POLLOUT : 0; } if (fds[i].fd.channel->remote.close @@ -1394,11 +1379,13 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout) break; case LIBSSH2_POLLFD_LISTENER: - if ((fds[i].events & LIBSSH2_POLLFD_POLLIN) && /* Want a connection */ - ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) { /* No connections known of yet */ + if ((fds[i].events & LIBSSH2_POLLFD_POLLIN) && + /* Want a connection */ + ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) { + /* No connections known of yet */ fds[i].revents |= - libssh2_poll_listener_queued(fds[i].fd. - listener) ? + poll_listener_queued(fds[i].fd. + listener) ? LIBSSH2_POLLFD_POLLIN : 0; } if (fds[i].fd.listener->session->socket_state == @@ -1444,7 +1431,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout) switch (fds[i].type) { case LIBSSH2_POLLFD_SOCKET: fds[i].revents = sockets[i].revents; - sockets[i].revents = 0; /* In case we loop again, be nice */ + sockets[i].revents = 0; /* In case we loop again, be nice */ if (fds[i].revents) { active_fds++; } @@ -1452,7 +1439,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout) case LIBSSH2_POLLFD_CHANNEL: if (sockets[i].events & POLLIN) { /* Spin session until no data available */ - while (libssh2_packet_read(fds[i].fd.channel->session) + while (_libssh2_packet_read(fds[i].fd.channel->session) > 0); } if (sockets[i].revents & POLLHUP) { @@ -1465,7 +1452,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout) case LIBSSH2_POLLFD_LISTENER: if (sockets[i].events & POLLIN) { /* Spin session until no data available */ - while (libssh2_packet_read(fds[i].fd.listener->session) + while (_libssh2_packet_read(fds[i].fd.listener->session) > 0); } if (sockets[i].revents & POLLHUP) { @@ -1534,13 +1521,16 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout) } } } -#endif /* else no select() or poll() -- timeout (and by extension timeout_remaining) will be equal to 0 */ +#endif /* else no select() or poll() -- timeout (and by extension + * timeout_remaining) will be equal to 0 */ } while ((timeout_remaining > 0) && !active_fds); return active_fds; } -/* {{{ libssh2_session_block_direction +/* + * libssh2_session_block_direction + * * Get blocked direction when a function returns LIBSSH2_ERROR_EAGAIN * Returns LIBSSH2_SOCKET_BLOCK_INBOUND if recv() blocked * or LIBSSH2_SOCKET_BLOCK_OUTBOUND if send() blocked @@ -1551,4 +1541,3 @@ libssh2_session_block_directions(LIBSSH2_SESSION *session) return session->socket_block_directions; } -/* }}} */ diff --git a/src/sftp.c b/src/sftp.c index 92666f1..26a703f 100644 --- a/src/sftp.c +++ b/src/sftp.c @@ -164,7 +164,7 @@ sftp_packet_read(LIBSSH2_SFTP * sftp) return -1; } - packet_len = libssh2_ntohu32(buffer); + packet_len = _libssh2_ntohu32(buffer); _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Data begin - Packet Length: %lu", packet_len); if (packet_len > LIBSSH2_SFTP_PACKET_MAXLEN) { @@ -243,7 +243,7 @@ sftp_packet_ask(LIBSSH2_SFTP * sftp, unsigned char packet_type, match_len = 1; } else { match_len = 5; - libssh2_htonu32(match_buf + 1, request_id); + _libssh2_htonu32(match_buf + 1, request_id); } while (packet) { @@ -364,7 +364,7 @@ sftp_packet_requirev(LIBSSH2_SFTP * sftp, int num_valid_responses, sftp->requirev_start = 0; return PACKET_TIMEOUT; } else if (sftp->channel->session->socket_block - && (libssh2_waitsocket(sftp->channel->session, left) <= + && (_libssh2_waitsocket(sftp->channel->session, left) <= 0)) { sftp->requirev_start = 0; return PACKET_TIMEOUT; @@ -420,34 +420,34 @@ libssh2_sftp_attr2bin(unsigned char *p, const LIBSSH2_SFTP_ATTRIBUTES * attrs) /* TODO: When we add SFTP4+ functionality flag_mask can get additional bits */ if (!attrs) { - libssh2_htonu32(s, 0); + _libssh2_htonu32(s, 0); return 4; } - libssh2_htonu32(s, attrs->flags & flag_mask); + _libssh2_htonu32(s, attrs->flags & flag_mask); s += 4; if (attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) { - libssh2_htonu64(s, attrs->filesize); + _libssh2_htonu64(s, attrs->filesize); s += 8; } if (attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) { - libssh2_htonu32(s, attrs->uid); + _libssh2_htonu32(s, attrs->uid); s += 4; - libssh2_htonu32(s, attrs->gid); + _libssh2_htonu32(s, attrs->gid); s += 4; } if (attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) { - libssh2_htonu32(s, attrs->permissions); + _libssh2_htonu32(s, attrs->permissions); s += 4; } if (attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) { - libssh2_htonu32(s, attrs->atime); + _libssh2_htonu32(s, attrs->atime); s += 4; - libssh2_htonu32(s, attrs->mtime); + _libssh2_htonu32(s, attrs->mtime); s += 4; } @@ -464,30 +464,30 @@ libssh2_sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES * attrs, const unsigned char *p) const unsigned char *s = p; memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES)); - attrs->flags = libssh2_ntohu32(s); + attrs->flags = _libssh2_ntohu32(s); s += 4; if (attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) { - attrs->filesize = libssh2_ntohu64(s); + attrs->filesize = _libssh2_ntohu64(s); s += 8; } if (attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) { - attrs->uid = libssh2_ntohu32(s); + attrs->uid = _libssh2_ntohu32(s); s += 4; - attrs->gid = libssh2_ntohu32(s); + attrs->gid = _libssh2_ntohu32(s); s += 4; } if (attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) { - attrs->permissions = libssh2_ntohu32(s); + attrs->permissions = _libssh2_ntohu32(s); s += 4; } if (attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) { - attrs->atime = libssh2_ntohu32(s); + attrs->atime = _libssh2_ntohu32(s); s += 4; - attrs->mtime = libssh2_ntohu32(s); + attrs->mtime = _libssh2_ntohu32(s); s += 4; } @@ -614,9 +614,9 @@ libssh2_sftp_init(LIBSSH2_SESSION * session) session->sftpInit_sftp->channel = session->sftpInit_channel; session->sftpInit_sftp->request_id = 0; - libssh2_htonu32(session->sftpInit_buffer, 5); + _libssh2_htonu32(session->sftpInit_buffer, 5); 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, "Sending FXP_INIT packet advertising version %d support", @@ -661,7 +661,7 @@ libssh2_sftp_init(LIBSSH2_SESSION * session) } s = data + 1; - session->sftpInit_sftp->version = libssh2_ntohu32(s); + session->sftpInit_sftp->version = _libssh2_ntohu32(s); s += 4; if (session->sftpInit_sftp->version > LIBSSH2_SFTP_VERSION) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, @@ -676,12 +676,12 @@ libssh2_sftp_init(LIBSSH2_SESSION * session) unsigned char *extension_name, *extension_data; unsigned long extname_len, extdata_len; - extname_len = libssh2_ntohu32(s); + extname_len = _libssh2_ntohu32(s); s += 4; extension_name = s; s += extname_len; - extdata_len = libssh2_ntohu32(s); + extdata_len = _libssh2_ntohu32(s); s += 4; extension_data = s; s += extdata_len; @@ -814,20 +814,20 @@ libssh2_sftp_open_ex(LIBSSH2_SFTP * sftp, const char *filename, LIBSSH2_SFTP_OPENFILE) ? LIBSSH2_SFTP_ATTR_PFILETYPE_FILE : LIBSSH2_SFTP_ATTR_PFILETYPE_DIR); - libssh2_htonu32(s, sftp->open_packet_len - 4); + _libssh2_htonu32(s, sftp->open_packet_len - 4); s += 4; *(s++) = (open_type == LIBSSH2_SFTP_OPENFILE) ? SSH_FXP_OPEN : SSH_FXP_OPENDIR; sftp->open_request_id = sftp->request_id++; - libssh2_htonu32(s, sftp->open_request_id); + _libssh2_htonu32(s, sftp->open_request_id); s += 4; - libssh2_htonu32(s, filename_len); + _libssh2_htonu32(s, filename_len); s += 4; memcpy(s, filename, filename_len); s += filename_len; if (open_type == LIBSSH2_SFTP_OPENFILE) { - libssh2_htonu32(s, flags); + _libssh2_htonu32(s, flags); s += 4; s += libssh2_sftp_attr2bin(s, &attrs); } @@ -890,7 +890,7 @@ libssh2_sftp_open_ex(LIBSSH2_SFTP * sftp, const char *filename, we need to properly deal with that. */ if (data[0] == SSH_FXP_STATUS) { int badness = 1; - sftp->last_errno = libssh2_ntohu32(data + 5); + sftp->last_errno = _libssh2_ntohu32(data + 5); if(LIBSSH2_FX_OK == sftp->last_errno) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "got HANDLE FXOK!"); @@ -931,7 +931,7 @@ libssh2_sftp_open_ex(LIBSSH2_SFTP * sftp, const char *filename, LIBSSH2_SFTP_OPENFILE) ? LIBSSH2_SFTP_HANDLE_FILE : LIBSSH2_SFTP_HANDLE_DIR; - fp->handle_len = libssh2_ntohu32(data + 5); + fp->handle_len = _libssh2_ntohu32(data + 5); if (fp->handle_len > SFTP_HANDLE_MAXLEN) { /* SFTP doesn't allow handles longer than 256 characters */ fp->handle_len = SFTP_HANDLE_MAXLEN; @@ -1022,22 +1022,22 @@ libssh2_sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer, #endif if (sftp->read_state == libssh2_NB_state_allocated) { - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_READ; request_id = sftp->request_id++; - libssh2_htonu32(s, request_id); + _libssh2_htonu32(s, request_id); s += 4; - libssh2_htonu32(s, handle->handle_len); + _libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; - libssh2_htonu64(s, handle->u.file.offset); + _libssh2_htonu64(s, handle->u.file.offset); s += 8; - libssh2_htonu32(s, bytes_requested); + _libssh2_htonu32(s, bytes_requested); s += 4; sftp->read_state = libssh2_NB_state_created; @@ -1089,7 +1089,7 @@ libssh2_sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer, switch (data[0]) { case SSH_FXP_STATUS: - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); sftp->read_packet = NULL; sftp->read_state = libssh2_NB_state_idle; @@ -1104,7 +1104,7 @@ libssh2_sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer, } case SSH_FXP_DATA: - bytes_read = libssh2_ntohu32(data + 5); + bytes_read = _libssh2_ntohu32(data + 5); if (bytes_read > (data_len - 9)) { sftp->read_packet = NULL; sftp->read_state = libssh2_NB_state_idle; @@ -1160,7 +1160,7 @@ libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE * handle, char *buffer, * feed it back from the buffer */ unsigned char *s = (unsigned char *) handle->u.dir.next_name; - unsigned long real_filename_len = libssh2_ntohu32(s); + unsigned long real_filename_len = _libssh2_ntohu32(s); filename_len = real_filename_len; s += 4; @@ -1177,9 +1177,9 @@ libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE * handle, char *buffer, if ((longentry == NULL) || (longentry_maxlen == 0)) { /* Skip longname */ - s += 4 + libssh2_ntohu32(s); + s += 4 + _libssh2_ntohu32(s); } else { - unsigned long real_longentry_len = libssh2_ntohu32(s); + unsigned long real_longentry_len = _libssh2_ntohu32(s); longentry_len = real_longentry_len; s += 4; @@ -1221,13 +1221,13 @@ libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE * handle, char *buffer, return -1; } - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_READDIR; sftp->readdir_request_id = sftp->request_id++; - libssh2_htonu32(s, sftp->readdir_request_id); + _libssh2_htonu32(s, sftp->readdir_request_id); s += 4; - libssh2_htonu32(s, handle->handle_len); + _libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; @@ -1275,7 +1275,7 @@ libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE * handle, char *buffer, } if (data[0] == SSH_FXP_STATUS) { - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_EOF) { sftp->readdir_state = libssh2_NB_state_idle; @@ -1289,7 +1289,7 @@ libssh2_sftp_readdir_ex(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", num_names); if (num_names <= 0) { @@ -1299,7 +1299,7 @@ libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE * handle, char *buffer, } if (num_names == 1) { - unsigned long real_filename_len = libssh2_ntohu32(data + 9); + unsigned long real_filename_len = _libssh2_ntohu32(data + 9); filename_len = real_filename_len; if (filename_len > buffer_maxlen) { @@ -1316,7 +1316,7 @@ libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE * handle, char *buffer, memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES)); libssh2_sftp_bin2attr(attrs, data + 13 + real_filename_len + (4 + - libssh2_ntohu32(data + 13 + + _libssh2_ntohu32(data + 13 + real_filename_len))); } LIBSSH2_FREE(session, data); @@ -1365,19 +1365,19 @@ libssh2_sftp_write(LIBSSH2_SFTP_HANDLE * handle, const char *buffer, return -1; } - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_WRITE; sftp->write_request_id = sftp->request_id++; - libssh2_htonu32(s, sftp->write_request_id); + _libssh2_htonu32(s, sftp->write_request_id); s += 4; - libssh2_htonu32(s, handle->handle_len); + _libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; - libssh2_htonu64(s, handle->u.file.offset); + _libssh2_htonu64(s, handle->u.file.offset); s += 8; - libssh2_htonu32(s, count); + _libssh2_htonu32(s, count); s += 4; memcpy(s, buffer, count); s += count; @@ -1418,7 +1418,7 @@ libssh2_sftp_write(LIBSSH2_SFTP_HANDLE * handle, const char *buffer, sftp->write_state = libssh2_NB_state_idle; - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { @@ -1464,13 +1464,13 @@ libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE * handle, return -1; } - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = setstat ? SSH_FXP_FSETSTAT : SSH_FXP_FSTAT; sftp->fstat_request_id = sftp->request_id++; - libssh2_htonu32(s, sftp->fstat_request_id); + _libssh2_htonu32(s, sftp->fstat_request_id); s += 4; - libssh2_htonu32(s, handle->handle_len); + _libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; @@ -1518,7 +1518,7 @@ libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE * handle, if (data[0] == SSH_FXP_STATUS) { int retcode; - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { return 0; @@ -1605,13 +1605,13 @@ libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE * handle) return -1; } - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_CLOSE; handle->close_request_id = sftp->request_id++; - libssh2_htonu32(s, handle->close_request_id); + _libssh2_htonu32(s, handle->close_request_id); s += 4; - libssh2_htonu32(s, handle->handle_len); + _libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; @@ -1655,7 +1655,7 @@ libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE * handle) handle->close_state = libssh2_NB_state_sent1; } - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode != LIBSSH2_FX_OK) { @@ -1717,13 +1717,13 @@ libssh2_sftp_unlink_ex(LIBSSH2_SFTP * sftp, const char *filename, return -1; } - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_REMOVE; sftp->unlink_request_id = sftp->request_id++; - libssh2_htonu32(s, sftp->unlink_request_id); + _libssh2_htonu32(s, sftp->unlink_request_id); s += 4; - libssh2_htonu32(s, filename_len); + _libssh2_htonu32(s, filename_len); s += 4; memcpy(s, filename, filename_len); s += filename_len; @@ -1765,7 +1765,7 @@ libssh2_sftp_unlink_ex(LIBSSH2_SFTP * sftp, const char *filename, sftp->unlink_state = libssh2_NB_state_idle; - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { @@ -1818,23 +1818,23 @@ libssh2_sftp_rename_ex(LIBSSH2_SFTP * sftp, const char *source_filename, return -1; } - libssh2_htonu32(sftp->rename_s, packet_len - 4); + _libssh2_htonu32(sftp->rename_s, packet_len - 4); sftp->rename_s += 4; *(sftp->rename_s++) = SSH_FXP_RENAME; sftp->rename_request_id = sftp->request_id++; - libssh2_htonu32(sftp->rename_s, sftp->rename_request_id); + _libssh2_htonu32(sftp->rename_s, sftp->rename_request_id); sftp->rename_s += 4; - libssh2_htonu32(sftp->rename_s, source_filename_len); + _libssh2_htonu32(sftp->rename_s, source_filename_len); sftp->rename_s += 4; memcpy(sftp->rename_s, source_filename, source_filename_len); sftp->rename_s += source_filename_len; - libssh2_htonu32(sftp->rename_s, dest_filename_len); + _libssh2_htonu32(sftp->rename_s, dest_filename_len); sftp->rename_s += 4; memcpy(sftp->rename_s, dest_filename, dest_filename_len); sftp->rename_s += dest_filename_len; if (sftp->version >= 5) { - libssh2_htonu32(sftp->rename_s, flags); + _libssh2_htonu32(sftp->rename_s, flags); sftp->rename_s += 4; } @@ -1874,7 +1874,7 @@ libssh2_sftp_rename_ex(LIBSSH2_SFTP * sftp, const char *source_filename, sftp->rename_state = libssh2_NB_state_idle; - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); switch (retcode) { @@ -1939,13 +1939,13 @@ libssh2_sftp_mkdir_ex(LIBSSH2_SFTP * sftp, const char *path, /* Filetype in SFTP 3 and earlier */ attrs.permissions = mode | LIBSSH2_SFTP_ATTR_PFILETYPE_DIR; - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_MKDIR; sftp->mkdir_request_id = sftp->request_id++; - libssh2_htonu32(s, sftp->mkdir_request_id); + _libssh2_htonu32(s, sftp->mkdir_request_id); s += 4; - libssh2_htonu32(s, path_len); + _libssh2_htonu32(s, path_len); s += 4; memcpy(s, path, path_len); s += path_len; @@ -1987,7 +1987,7 @@ libssh2_sftp_mkdir_ex(LIBSSH2_SFTP * sftp, const char *path, sftp->mkdir_state = libssh2_NB_state_idle; - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { @@ -2029,13 +2029,13 @@ libssh2_sftp_rmdir_ex(LIBSSH2_SFTP * sftp, const char *path, return -1; } - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_RMDIR; sftp->rmdir_request_id = sftp->request_id++; - libssh2_htonu32(s, sftp->rmdir_request_id); + _libssh2_htonu32(s, sftp->rmdir_request_id); s += 4; - libssh2_htonu32(s, path_len); + _libssh2_htonu32(s, path_len); s += 4; memcpy(s, path, path_len); s += path_len; @@ -2075,7 +2075,7 @@ libssh2_sftp_rmdir_ex(LIBSSH2_SFTP * sftp, const char *path, sftp->rmdir_state = libssh2_NB_state_idle; - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { @@ -2124,7 +2124,7 @@ libssh2_sftp_stat_ex(LIBSSH2_SFTP * sftp, const char *path, return -1; } - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; switch (stat_type) { case LIBSSH2_SFTP_SETSTAT: @@ -2140,9 +2140,9 @@ libssh2_sftp_stat_ex(LIBSSH2_SFTP * sftp, const char *path, *(s++) = SSH_FXP_STAT; } sftp->stat_request_id = sftp->request_id++; - libssh2_htonu32(s, sftp->stat_request_id); + _libssh2_htonu32(s, sftp->stat_request_id); s += 4; - libssh2_htonu32(s, path_len); + _libssh2_htonu32(s, path_len); s += 4; memcpy(s, path, path_len); s += path_len; @@ -2188,7 +2188,7 @@ libssh2_sftp_stat_ex(LIBSSH2_SFTP * sftp, const char *path, if (data[0] == SSH_FXP_STATUS) { int retcode; - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { return 0; @@ -2250,7 +2250,7 @@ libssh2_sftp_symlink_ex(LIBSSH2_SFTP * sftp, const char *path, (link_type == LIBSSH2_SFTP_REALPATH) ? "realpath" : "symlink", path); - libssh2_htonu32(s, packet_len - 4); + _libssh2_htonu32(s, packet_len - 4); s += 4; switch (link_type) { case LIBSSH2_SFTP_REALPATH: @@ -2266,14 +2266,14 @@ libssh2_sftp_symlink_ex(LIBSSH2_SFTP * sftp, const char *path, *(s++) = SSH_FXP_READLINK; } sftp->symlink_request_id = sftp->request_id++; - libssh2_htonu32(s, sftp->symlink_request_id); + _libssh2_htonu32(s, sftp->symlink_request_id); s += 4; - libssh2_htonu32(s, path_len); + _libssh2_htonu32(s, path_len); s += 4; memcpy(s, path, path_len); s += path_len; if (link_type == LIBSSH2_SFTP_SYMLINK) { - libssh2_htonu32(s, target_len); + _libssh2_htonu32(s, target_len); s += 4; memcpy(s, target, target_len); s += target_len; @@ -2320,7 +2320,7 @@ libssh2_sftp_symlink_ex(LIBSSH2_SFTP * sftp, const char *path, if (data[0] == SSH_FXP_STATUS) { int retcode; - retcode = libssh2_ntohu32(data + 5); + retcode = _libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { return 0; @@ -2332,7 +2332,7 @@ libssh2_sftp_symlink_ex(LIBSSH2_SFTP * sftp, const char *path, } } - if (libssh2_ntohu32(data + 5) < 1) { + if (_libssh2_ntohu32(data + 5) < 1) { libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "Invalid READLINK/REALPATH response, no name entries", 0); @@ -2340,7 +2340,7 @@ libssh2_sftp_symlink_ex(LIBSSH2_SFTP * sftp, const char *path, return -1; } - link_len = libssh2_ntohu32(data + 9); + link_len = _libssh2_ntohu32(data + 9); if (link_len >= target_len) { link_len = target_len - 1; } diff --git a/src/transport.c b/src/transport.c index 6b22745..dffa4d4 100644 --- a/src/transport.c +++ b/src/transport.c @@ -227,9 +227,9 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ ) } if (session->fullpacket_state == libssh2_NB_state_created) { - rc = libssh2_packet_add(session, p->payload, - session->fullpacket_payload_len, - session->fullpacket_macstate); + rc = _libssh2_packet_add(session, p->payload, + session->fullpacket_payload_len, + session->fullpacket_macstate); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc < 0) { @@ -244,7 +244,7 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ ) /* - * libssh2_packet_read + * _libssh2_packet_read * * Collect a packet into the input brigade block only controls whether or not * to wait for a packet to start. @@ -259,7 +259,7 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ ) * "The Secure Shell (SSH) Transport Layer Protocol" */ libssh2pack_t -libssh2_packet_read(LIBSSH2_SESSION * session) +_libssh2_packet_read(LIBSSH2_SESSION * session) { libssh2pack_t rc; struct transportpacket *p = &session->packet; @@ -438,7 +438,7 @@ libssh2_packet_read(LIBSSH2_SESSION * session) /* we now have the initial blocksize bytes decrypted, * and we can extract packet and padding length from it */ - p->packet_length = libssh2_ntohu32(block); + p->packet_length = _libssh2_ntohu32(block); p->padding_length = block[4]; /* total_num is the number of bytes following the initial @@ -661,8 +661,8 @@ send_existing(LIBSSH2_SESSION * session, unsigned char *data, * (RFC4253 section 6.1) */ int -libssh2_packet_write(LIBSSH2_SESSION * session, unsigned char *data, - unsigned long data_len) +_libssh2_packet_write(LIBSSH2_SESSION * session, unsigned char *data, + unsigned long data_len) { int blocksize = (session->state & LIBSSH2_STATE_NEWKEYS) ? session->local.crypt-> @@ -752,7 +752,7 @@ libssh2_packet_write(LIBSSH2_SESSION * session, unsigned char *data, /* store packet_length, which is the size of the whole packet except the MAC and the packet_length field itself */ - libssh2_htonu32(p->outbuf, packet_length - 4); + _libssh2_htonu32(p->outbuf, packet_length - 4); /* store padding_length */ p->outbuf[4] = padding_length; /* copy the payload data */ diff --git a/src/userauth.c b/src/userauth.c index 8251b06..47b430e 100644 --- a/src/userauth.c +++ b/src/userauth.c @@ -80,19 +80,19 @@ libssh2_userauth_list(LIBSSH2_SESSION * session, const char *username, } *(s++) = SSH_MSG_USERAUTH_REQUEST; - libssh2_htonu32(s, username_len); + _libssh2_htonu32(s, username_len); s += 4; if (username) { memcpy(s, username, username_len); s += username_len; } - libssh2_htonu32(s, 14); + _libssh2_htonu32(s, 14); s += 4; memcpy(s, "ssh-connection", 14); s += 14; - libssh2_htonu32(s, 4); + _libssh2_htonu32(s, 4); s += 4; memcpy(s, "none", 4); s += 4; @@ -101,7 +101,7 @@ libssh2_userauth_list(LIBSSH2_SESSION * session, const char *username, } if (session->userauth_list_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, session->userauth_list_data, + rc = _libssh2_packet_write(session, session->userauth_list_data, session->userauth_list_data_len); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, @@ -122,11 +122,11 @@ libssh2_userauth_list(LIBSSH2_SESSION * session, const char *username, } if (session->userauth_list_state == libssh2_NB_state_sent) { - rc = libssh2_packet_requirev(session, reply_codes, - &session->userauth_list_data, - &session->userauth_list_data_len, 0, - NULL, 0, - &session->userauth_list_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, + &session->userauth_list_data, + &session->userauth_list_data_len, 0, + NULL, 0, + &session->userauth_list_packet_requirev_state); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block requesting userauth list", 0); @@ -147,11 +147,11 @@ libssh2_userauth_list(LIBSSH2_SESSION * session, const char *username, return NULL; } - methods_len = libssh2_ntohu32(session->userauth_list_data + 1); + methods_len = _libssh2_ntohu32(session->userauth_list_data + 1); /* Do note that the memory areas overlap! */ memmove(session->userauth_list_data, session->userauth_list_data + 5, - methods_len); + methods_len); session->userauth_list_data[methods_len] = '\0'; _libssh2_debug(session, LIBSSH2_DBG_AUTH, "Permitted auth methods: %s", session->userauth_list_data); @@ -161,10 +161,10 @@ libssh2_userauth_list(LIBSSH2_SESSION * session, const char *username, return (char *) session->userauth_list_data; } -/* }}} */ - -/* {{{ libssh2_userauth_authenticated - * 0 if not yet authenticated +/* + * libssh2_userauth_authenticated + * + * Returns: 0 if not yet authenticated * non-zero is already authenticated */ LIBSSH2_API int @@ -197,7 +197,7 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username, sizeof(session->userauth_pswd_packet_requirev_state)); /* - * 40 = acket_type(1) + username_len(4) + service_len(4) + + * 40 = acket_type(1) + username_len(4) + service_len(4) + * service(14)"ssh-connection" + method_len(4) + method(8)"password" + * chgpwdbool(1) + password_len(4) */ session->userauth_pswd_data_len = username_len + password_len + 40; @@ -214,17 +214,17 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username, } *(s++) = SSH_MSG_USERAUTH_REQUEST; - libssh2_htonu32(s, username_len); + _libssh2_htonu32(s, username_len); s += 4; memcpy(s, username, username_len); s += username_len; - libssh2_htonu32(s, sizeof("ssh-connection") - 1); + _libssh2_htonu32(s, sizeof("ssh-connection") - 1); s += 4; memcpy(s, "ssh-connection", sizeof("ssh-connection") - 1); s += sizeof("ssh-connection") - 1; - libssh2_htonu32(s, sizeof("password") - 1); + _libssh2_htonu32(s, sizeof("password") - 1); s += 4; memcpy(s, "password", sizeof("password") - 1); s += sizeof("password") - 1; @@ -232,7 +232,7 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username, *s = '\0'; s++; - libssh2_htonu32(s, password_len); + _libssh2_htonu32(s, password_len); s += 4; memcpy(s, password, password_len); s += password_len; @@ -244,7 +244,7 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username, } if (session->userauth_pswd_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, session->userauth_pswd_data, + rc = _libssh2_packet_write(session, session->userauth_pswd_data, session->userauth_pswd_data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; @@ -268,12 +268,12 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username, || (session->userauth_pswd_state == libssh2_NB_state_sent1) || (session->userauth_pswd_state == libssh2_NB_state_sent2)) { if (session->userauth_pswd_state == libssh2_NB_state_sent) { - rc = libssh2_packet_requirev(session, reply_codes, - &session->userauth_pswd_data, - &session->userauth_pswd_data_len, - 0, NULL, 0, - &session-> - userauth_pswd_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, + &session->userauth_pswd_data, + &session->userauth_pswd_data_len, + 0, NULL, 0, + &session-> + userauth_pswd_packet_requirev_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -344,18 +344,18 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username, } *(s++) = SSH_MSG_USERAUTH_REQUEST; - libssh2_htonu32(s, username_len); + _libssh2_htonu32(s, username_len); s += 4; memcpy(s, username, username_len); s += username_len; - libssh2_htonu32(s, sizeof("ssh-connection") - 1); + _libssh2_htonu32(s, sizeof("ssh-connection") - 1); s += 4; memcpy(s, "ssh-connection", sizeof("ssh-connection") - 1); s += sizeof("ssh-connection") - 1; - libssh2_htonu32(s, sizeof("password") - 1); + _libssh2_htonu32(s, sizeof("password") - 1); s += 4; memcpy(s, "password", sizeof("password") - 1); s += sizeof("password") - 1; @@ -363,12 +363,12 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username, *s = 0x01; s++; - libssh2_htonu32(s, password_len); + _libssh2_htonu32(s, password_len); s += 4; memcpy(s, password, password_len); s += password_len; - libssh2_htonu32(s, session->userauth_pswd_newpw_len); + _libssh2_htonu32(s, session->userauth_pswd_newpw_len); s += 4; memcpy(s, session->userauth_pswd_newpw, session->userauth_pswd_newpw_len); @@ -378,7 +378,7 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username, } if (session->userauth_pswd_state == libssh2_NB_state_sent2) { - rc = libssh2_packet_write(session, + rc = _libssh2_packet_write(session, session->userauth_pswd_data, session-> userauth_pswd_data_len); @@ -427,15 +427,17 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username, /* }}} */ -/* {{{ libssh2_file_read_publickey +/* + * file_read_publickey + * * Read a public key from an id_???.pub style file */ static int -libssh2_file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method, - unsigned long *method_len, - unsigned char **pubkeydata, - unsigned long *pubkeydata_len, - const char *pubkeyfile) +file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method, + unsigned long *method_len, + unsigned char **pubkeydata, + unsigned long *pubkeydata_len, + const char *pubkeyfile) { FILE *fd; char c; @@ -502,7 +504,7 @@ libssh2_file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method, return -1; } /* Wasting some bytes here (okay, more than some), - * but since it's likely to be freed soon anyway, + * but since it's likely to be freed soon anyway, * we'll just avoid the extra free/alloc and call it a wash */ *method = pubkey; *method_len = sp1 - pubkey; @@ -606,17 +608,17 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION * session, memset(&session->userauth_host_packet_requirev_state, 0, sizeof(session->userauth_host_packet_requirev_state)); - if (libssh2_file_read_publickey - (session, &session->userauth_host_method, - &session->userauth_host_method_len, &pubkeydata, &pubkeydata_len, - publickey)) { + if (file_read_publickey(session, &session->userauth_host_method, + &session->userauth_host_method_len, + &pubkeydata, &pubkeydata_len, + publickey)) { return -1; } /* - * 48 = packet_type(1) + username_len(4) + servicename_len(4) + + * 48 = packet_type(1) + username_len(4) + servicename_len(4) + * service_name(14)"ssh-connection" + authmethod_len(4) + - * authmethod(9)"hostbased" + method_len(4) + pubkeydata_len(4) + + * authmethod(9)"hostbased" + method_len(4) + pubkeydata_len(4) + * local_username_len(4) */ session->userauth_host_packet_len = @@ -625,7 +627,7 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION * session, /* * Preallocate space for an overall length, method name again, - * and the signature, which won't be any larger than the size of + * and the signature, which won't be any larger than the size of * the publickeydata itself */ session->userauth_host_s = session->userauth_host_packet = @@ -641,39 +643,39 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION * session, } *(session->userauth_host_s++) = SSH_MSG_USERAUTH_REQUEST; - libssh2_htonu32(session->userauth_host_s, username_len); + _libssh2_htonu32(session->userauth_host_s, username_len); session->userauth_host_s += 4; memcpy(session->userauth_host_s, username, username_len); session->userauth_host_s += username_len; - libssh2_htonu32(session->userauth_host_s, 14); + _libssh2_htonu32(session->userauth_host_s, 14); session->userauth_host_s += 4; memcpy(session->userauth_host_s, "ssh-connection", 14); session->userauth_host_s += 14; - libssh2_htonu32(session->userauth_host_s, 9); + _libssh2_htonu32(session->userauth_host_s, 9); session->userauth_host_s += 4; memcpy(session->userauth_host_s, "hostbased", 9); session->userauth_host_s += 9; - libssh2_htonu32(session->userauth_host_s, + _libssh2_htonu32(session->userauth_host_s, session->userauth_host_method_len); session->userauth_host_s += 4; memcpy(session->userauth_host_s, session->userauth_host_method, session->userauth_host_method_len); session->userauth_host_s += session->userauth_host_method_len; - libssh2_htonu32(session->userauth_host_s, pubkeydata_len); + _libssh2_htonu32(session->userauth_host_s, pubkeydata_len); session->userauth_host_s += 4; memcpy(session->userauth_host_s, pubkeydata, pubkeydata_len); session->userauth_host_s += pubkeydata_len; - libssh2_htonu32(session->userauth_host_s, hostname_len); + _libssh2_htonu32(session->userauth_host_s, hostname_len); session->userauth_host_s += 4; memcpy(session->userauth_host_s, hostname, hostname_len); session->userauth_host_s += hostname_len; - libssh2_htonu32(session->userauth_host_s, local_username_len); + _libssh2_htonu32(session->userauth_host_s, local_username_len); session->userauth_host_s += 4; memcpy(session->userauth_host_s, local_username, local_username_len); session->userauth_host_s += local_username_len; @@ -688,7 +690,7 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION * session, return -1; } - libssh2_htonu32(buf, session->session_id_len); + _libssh2_htonu32(buf, session->session_id_len); datavec[0].iov_base = buf; datavec[0].iov_len = 4; datavec[1].iov_base = session->session_id; @@ -732,11 +734,11 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION * session, session->userauth_host_s = session->userauth_host_packet + session->userauth_host_packet_len; - libssh2_htonu32(session->userauth_host_s, + _libssh2_htonu32(session->userauth_host_s, 4 + session->userauth_host_method_len + 4 + sig_len); session->userauth_host_s += 4; - libssh2_htonu32(session->userauth_host_s, + _libssh2_htonu32(session->userauth_host_s, session->userauth_host_method_len); session->userauth_host_s += 4; memcpy(session->userauth_host_s, session->userauth_host_method, @@ -745,7 +747,7 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION * session, LIBSSH2_FREE(session, session->userauth_host_method); session->userauth_host_method = NULL; - libssh2_htonu32(session->userauth_host_s, sig_len); + _libssh2_htonu32(session->userauth_host_s, sig_len); session->userauth_host_s += 4; memcpy(session->userauth_host_s, sig, sig_len); session->userauth_host_s += sig_len; @@ -758,7 +760,7 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION * session, } if (session->userauth_host_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, session->userauth_host_packet, + rc = _libssh2_packet_write(session, session->userauth_host_packet, session->userauth_host_s - session->userauth_host_packet); if (rc == PACKET_EAGAIN) { @@ -779,11 +781,11 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION * session, if (session->userauth_host_state == libssh2_NB_state_sent) { unsigned long data_len; - rc = libssh2_packet_requirev(session, reply_codes, - &session->userauth_host_data, - &data_len, 0, NULL, 0, - &session-> - userauth_host_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, + &session->userauth_host_data, + &data_len, 0, NULL, 0, + &session-> + userauth_host_packet_requirev_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -840,16 +842,15 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, memset(&session->userauth_pblc_packet_requirev_state, 0, sizeof(session->userauth_pblc_packet_requirev_state)); - if (libssh2_file_read_publickey - (session, &session->userauth_pblc_method, - &session->userauth_pblc_method_len, &pubkeydata, &pubkeydata_len, - publickey)) { + if (file_read_publickey(session, &session->userauth_pblc_method, + &session->userauth_pblc_method_len, + &pubkeydata, &pubkeydata_len,publickey)) { return -1; } /* - * 45 = packet_type(1) + username_len(4) + servicename_len(4) + - * service_name(14)"ssh-connection" + authmethod_len(4) + + * 45 = packet_type(1) + username_len(4) + servicename_len(4) + + * service_name(14)"ssh-connection" + authmethod_len(4) + * authmethod(9)"publickey" + sig_included(1)'\0' + algmethod_len(4) + * publickey_len(4) */ @@ -859,7 +860,7 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, /* * Preallocate space for an overall length, method name again, and - * the signature, which won't be any larger than the size of the + * the signature, which won't be any larger than the size of the * publickeydata itself */ session->userauth_pblc_s = session->userauth_pblc_packet = @@ -876,17 +877,17 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, } *(session->userauth_pblc_s++) = SSH_MSG_USERAUTH_REQUEST; - libssh2_htonu32(session->userauth_pblc_s, username_len); + _libssh2_htonu32(session->userauth_pblc_s, username_len); session->userauth_pblc_s += 4; memcpy(session->userauth_pblc_s, username, username_len); session->userauth_pblc_s += username_len; - libssh2_htonu32(session->userauth_pblc_s, 14); + _libssh2_htonu32(session->userauth_pblc_s, 14); session->userauth_pblc_s += 4; memcpy(session->userauth_pblc_s, "ssh-connection", 14); session->userauth_pblc_s += 14; - libssh2_htonu32(session->userauth_pblc_s, 9); + _libssh2_htonu32(session->userauth_pblc_s, 9); session->userauth_pblc_s += 4; memcpy(session->userauth_pblc_s, "publickey", 9); session->userauth_pblc_s += 9; @@ -895,14 +896,14 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, /* Not sending signature with *this* packet */ *(session->userauth_pblc_s++) = 0; - libssh2_htonu32(session->userauth_pblc_s, + _libssh2_htonu32(session->userauth_pblc_s, session->userauth_pblc_method_len); session->userauth_pblc_s += 4; memcpy(session->userauth_pblc_s, session->userauth_pblc_method, session->userauth_pblc_method_len); session->userauth_pblc_s += session->userauth_pblc_method_len; - libssh2_htonu32(session->userauth_pblc_s, pubkeydata_len); + _libssh2_htonu32(session->userauth_pblc_s, pubkeydata_len); session->userauth_pblc_s += 4; memcpy(session->userauth_pblc_s, pubkeydata, pubkeydata_len); session->userauth_pblc_s += pubkeydata_len; @@ -915,7 +916,7 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, } if (session->userauth_pblc_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, session->userauth_pblc_packet, + rc = _libssh2_packet_write(session, session->userauth_pblc_packet, session->userauth_pblc_packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; @@ -941,12 +942,12 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, unsigned char *sig; unsigned long sig_len; - rc = libssh2_packet_requirev(session, reply_codes, - &session->userauth_pblc_data, - &session->userauth_pblc_data_len, 0, - NULL, 0, - &session-> - userauth_pblc_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, + &session->userauth_pblc_data, + &session->userauth_pblc_data_len, 0, + NULL, 0, + &session-> + userauth_pblc_packet_requirev_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -1007,7 +1008,7 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, *session->userauth_pblc_b = 0x01; - libssh2_htonu32(buf, session->session_id_len); + _libssh2_htonu32(buf, session->session_id_len); datavec[0].iov_base = buf; datavec[0].iov_len = 4; datavec[1].iov_base = session->session_id; @@ -1031,10 +1032,10 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, privkeyobj->dtor(session, &abstract); } - /* - * If this function was restarted, pubkeydata_len might still be 0 - * which will cause an unnecessary but harmless realloc here. - */ + /* + * If this function was restarted, pubkeydata_len might still be 0 + * which will cause an unnecessary but harmless realloc here. + */ if (sig_len > pubkeydata_len) { unsigned char *newpacket; /* Should *NEVER* happen, but...well.. better safe than sorry */ @@ -1058,11 +1059,11 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, session->userauth_pblc_packet + session->userauth_pblc_packet_len; session->userauth_pblc_b = NULL; - libssh2_htonu32(session->userauth_pblc_s, + _libssh2_htonu32(session->userauth_pblc_s, 4 + session->userauth_pblc_method_len + 4 + sig_len); session->userauth_pblc_s += 4; - libssh2_htonu32(session->userauth_pblc_s, + _libssh2_htonu32(session->userauth_pblc_s, session->userauth_pblc_method_len); session->userauth_pblc_s += 4; memcpy(session->userauth_pblc_s, session->userauth_pblc_method, @@ -1071,7 +1072,7 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, LIBSSH2_FREE(session, session->userauth_pblc_method); session->userauth_pblc_method = NULL; - libssh2_htonu32(session->userauth_pblc_s, sig_len); + _libssh2_htonu32(session->userauth_pblc_s, sig_len); session->userauth_pblc_s += 4; memcpy(session->userauth_pblc_s, sig, sig_len); session->userauth_pblc_s += sig_len; @@ -1084,7 +1085,7 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, } if (session->userauth_pblc_state == libssh2_NB_state_sent1) { - rc = libssh2_packet_write(session, session->userauth_pblc_packet, + rc = _libssh2_packet_write(session, session->userauth_pblc_packet, session->userauth_pblc_s - session->userauth_pblc_packet); if (rc == PACKET_EAGAIN) { @@ -1106,10 +1107,10 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session, /* PK_OK is no longer valid */ reply_codes[2] = 0; - rc = libssh2_packet_requirev(session, reply_codes, - &session->userauth_pblc_data, - &session->userauth_pblc_data_len, 0, NULL, 0, - &session->userauth_pblc_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, + &session->userauth_pblc_data, + &session->userauth_pblc_data_len, 0, NULL, 0, + &session->userauth_pblc_packet_requirev_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -1190,29 +1191,29 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session, *s++ = SSH_MSG_USERAUTH_REQUEST; /* user name */ - libssh2_htonu32(s, username_len); + _libssh2_htonu32(s, username_len); s += 4; memcpy(s, username, username_len); s += username_len; /* service name */ - libssh2_htonu32(s, sizeof("ssh-connection") - 1); + _libssh2_htonu32(s, sizeof("ssh-connection") - 1); s += 4; memcpy(s, "ssh-connection", sizeof("ssh-connection") - 1); s += sizeof("ssh-connection") - 1; /* "keyboard-interactive" */ - libssh2_htonu32(s, sizeof("keyboard-interactive") - 1); + _libssh2_htonu32(s, sizeof("keyboard-interactive") - 1); s += 4; memcpy(s, "keyboard-interactive", sizeof("keyboard-interactive") - 1); s += sizeof("keyboard-interactive") - 1; /* language tag */ - libssh2_htonu32(s, 0); + _libssh2_htonu32(s, 0); s += 4; /* submethods */ - libssh2_htonu32(s, 0); + _libssh2_htonu32(s, 0); s += 4; _libssh2_debug(session, LIBSSH2_DBG_AUTH, @@ -1222,7 +1223,7 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session, } if (session->userauth_kybd_state == libssh2_NB_state_created) { - rc = libssh2_packet_write(session, session->userauth_kybd_data, + rc = _libssh2_packet_write(session, session->userauth_kybd_data, session->userauth_kybd_packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; @@ -1242,12 +1243,12 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session, for(;;) { if (session->userauth_kybd_state == libssh2_NB_state_sent) { - rc = libssh2_packet_requirev(session, reply_codes, - &session->userauth_kybd_data, - &session->userauth_kybd_data_len, - 0, NULL, 0, - &session-> - userauth_kybd_packet_requirev_state); + rc = _libssh2_packet_requirev(session, reply_codes, + &session->userauth_kybd_data, + &session->userauth_kybd_data_len, + 0, NULL, 0, + &session-> + userauth_kybd_packet_requirev_state); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { @@ -1277,7 +1278,7 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session, s = session->userauth_kybd_data + 1; /* string name (ISO-10646 UTF-8) */ - session->userauth_kybd_auth_name_len = libssh2_ntohu32(s); + session->userauth_kybd_auth_name_len = _libssh2_ntohu32(s); s += 4; session->userauth_kybd_auth_name = LIBSSH2_ALLOC(session, session->userauth_kybd_auth_name_len); @@ -1292,7 +1293,7 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session, s += session->userauth_kybd_auth_name_len; /* string instruction (ISO-10646 UTF-8) */ - session->userauth_kybd_auth_instruction_len = libssh2_ntohu32(s); + session->userauth_kybd_auth_instruction_len = _libssh2_ntohu32(s); s += 4; session->userauth_kybd_auth_instruction = LIBSSH2_ALLOC(session, @@ -1308,13 +1309,13 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session, s += session->userauth_kybd_auth_instruction_len; /* string language tag (as defined in [RFC-3066]) */ - language_tag_len = libssh2_ntohu32(s); + language_tag_len = _libssh2_ntohu32(s); s += 4; /* ignoring this field as deprecated */ s += language_tag_len; /* int num-prompts */ - session->userauth_kybd_num_prompts = libssh2_ntohu32(s); + session->userauth_kybd_num_prompts = _libssh2_ntohu32(s); s += 4; session->userauth_kybd_prompts = @@ -1347,7 +1348,7 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session, for(i = 0; i != session->userauth_kybd_num_prompts; ++i) { /* string prompt[1] (ISO-10646 UTF-8) */ - session->userauth_kybd_prompts[i].length = libssh2_ntohu32(s); + session->userauth_kybd_prompts[i].length = _libssh2_ntohu32(s); s += 4; session->userauth_kybd_prompts[i].text = LIBSSH2_ALLOC(session, @@ -1399,11 +1400,11 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session, *s = SSH_MSG_USERAUTH_INFO_RESPONSE; s++; - libssh2_htonu32(s, session->userauth_kybd_num_prompts); + _libssh2_htonu32(s, session->userauth_kybd_num_prompts); s += 4; for(i = 0; i != session->userauth_kybd_num_prompts; ++i) { - libssh2_htonu32(s, session->userauth_kybd_responses[i].length); + _libssh2_htonu32(s, session->userauth_kybd_responses[i].length); s += 4; memcpy(s, session->userauth_kybd_responses[i].text, session->userauth_kybd_responses[i].length); @@ -1414,8 +1415,8 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session, } if (session->userauth_kybd_state == libssh2_NB_state_sent1) { - rc = libssh2_packet_write(session, session->userauth_kybd_data, - session->userauth_kybd_packet_len); + rc = _libssh2_packet_write(session, session->userauth_kybd_data, + session->userauth_kybd_packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; }