From 71fb9cc93e25c895d58e645eabf4bbcaeeef76c7 Mon Sep 17 00:00:00 2001 From: Daniel Stenberg Date: Sat, 24 Apr 2010 21:14:16 +0200 Subject: [PATCH] cleanup: prefer the internal functions To get the blocking vs non-blocking to work as smooth as possible and behave better internally, we avoid using the external interfaces when calling functions internally. Renamed a few internal functions to use _libssh2 prefix when not being private within a file, and removed the libssh2_ for one that was private within the file. --- src/agent.c | 12 ++++++----- src/channel.c | 35 +++++++++++++++--------------- src/channel.h | 12 +++++++++++ src/kex.c | 6 +++--- src/knownhost.c | 18 ++++++++-------- src/libgcrypt.h | 2 +- src/libssh2_priv.h | 4 ++-- src/openssl.h | 2 +- src/packet.c | 7 +++--- src/publickey.c | 4 ++-- src/scp.c | 54 +++++++++++++++++++++++----------------------- src/session.c | 10 ++++----- src/transport.c | 4 ++-- src/userauth.c | 29 +++++++++++++------------ src/userauth.h | 50 ++++++++++++++++++++++++++++++++++++++++++ 15 files changed, 156 insertions(+), 93 deletions(-) create mode 100644 src/userauth.h diff --git a/src/agent.c b/src/agent.c index 82790c9..b0a112e 100644 --- a/src/agent.c +++ b/src/agent.c @@ -47,6 +47,7 @@ support them. */ #undef PF_UNIX #endif +#include "userauth.h" /* Requests from client to agent for protocol 1 key operations */ #define SSH_AGENTC_REQUEST_RSA_IDENTITIES 1 @@ -716,11 +717,12 @@ libssh2_agent_userauth(LIBSSH2_AGENT *agent, memset(&agent->transctx, 0, sizeof agent->transctx); agent->identity = identity->node; } - return libssh2_userauth_publickey(agent->session, username, - identity->blob, - identity->blob_len, - agent_sign, - &abstract); + return _libssh2_userauth_publickey(agent->session, username, + strlen(username), + identity->blob, + identity->blob_len, + agent_sign, + &abstract); } /* diff --git a/src/channel.c b/src/channel.c index 8f127c6..93aab2a 100644 --- a/src/channel.c +++ b/src/channel.c @@ -372,15 +372,12 @@ channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host, } channel = - libssh2_channel_open_ex(session, "direct-tcpip", - sizeof("direct-tcpip") - 1, - LIBSSH2_CHANNEL_WINDOW_DEFAULT, - LIBSSH2_CHANNEL_PACKET_DEFAULT, - (char *) session->direct_message, - session->direct_message_len); - - /* by default we set (keep?) idle state... */ - session->direct_state = libssh2_NB_state_idle; + _libssh2_channel_open(session, "direct-tcpip", + sizeof("direct-tcpip") - 1, + LIBSSH2_CHANNEL_WINDOW_DEFAULT, + LIBSSH2_CHANNEL_PACKET_DEFAULT, + (char *) session->direct_message, + session->direct_message_len); if (!channel && libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) { @@ -389,6 +386,8 @@ channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host, session->direct_state = libssh2_NB_state_created; return NULL; } + /* by default we set (keep?) idle state... */ + session->direct_state = libssh2_NB_state_idle; LIBSSH2_FREE(session, session->direct_message); session->direct_message = NULL; @@ -576,14 +575,14 @@ libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, const char *host, } /* - * 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 * * Return 0 on success, LIBSSH2_ERROR_EAGAIN if would block, -1 on error */ -static int channel_forward_cancel(LIBSSH2_LISTENER *listener) +int _libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener) { LIBSSH2_SESSION *session = listener->session; LIBSSH2_CHANNEL *queued; @@ -643,7 +642,7 @@ static int channel_forward_cancel(LIBSSH2_LISTENER *listener) while (queued) { LIBSSH2_CHANNEL *next = _libssh2_list_next(&queued->node); - rc = libssh2_channel_free(queued); + rc = _libssh2_channel_free(queued); if (rc == LIBSSH2_ERROR_EAGAIN) { return rc; } @@ -673,7 +672,8 @@ LIBSSH2_API int libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener) { int rc; - BLOCK_ADJUST(rc, listener->session, channel_forward_cancel(listener)); + BLOCK_ADJUST(rc, listener->session, + _libssh2_channel_forward_cancel(listener)); return rc; } @@ -1104,7 +1104,7 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection, border */ unsigned char buffer[(LIBSSH2_X11_RANDOM_COOKIE_LEN / 2) +1]; - libssh2_random(buffer, LIBSSH2_X11_RANDOM_COOKIE_LEN / 2); + _libssh2_random(buffer, LIBSSH2_X11_RANDOM_COOKIE_LEN / 2); for(i = 0; i < (LIBSSH2_X11_RANDOM_COOKIE_LEN / 2); i++) { sprintf((char *)&s[i*2], "%02X", buffer[i]); } @@ -2123,8 +2123,7 @@ libssh2_channel_wait_eof(LIBSSH2_CHANNEL *channel) return rc; } -static int -channel_close(LIBSSH2_CHANNEL * channel) +int _libssh2_channel_close(LIBSSH2_CHANNEL * channel) { LIBSSH2_SESSION *session = channel->session; int rc = 0; @@ -2202,7 +2201,7 @@ LIBSSH2_API int libssh2_channel_close(LIBSSH2_CHANNEL *channel) { int rc; - BLOCK_ADJUST(rc, channel->session, channel_close(channel) ); + BLOCK_ADJUST(rc, channel->session, _libssh2_channel_close(channel) ); return rc; } @@ -2292,7 +2291,7 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel) /* Allow channel freeing even when the socket has lost its connection */ if (!channel->local.close && (session->socket_state == LIBSSH2_SOCKET_CONNECTED)) { - rc = channel_close(channel); + rc = _libssh2_channel_close(channel); if(rc == LIBSSH2_ERROR_EAGAIN) return rc; diff --git a/src/channel.h b/src/channel.h index aa0aecf..15020d1 100644 --- a/src/channel.h +++ b/src/channel.h @@ -125,5 +125,17 @@ LIBSSH2_CHANNEL *_libssh2_channel_locate(LIBSSH2_SESSION * session, size_t _libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id); +int _libssh2_channel_close(LIBSSH2_CHANNEL * channel); + +/* + * _libssh2_channel_forward_cancel + * + * Stop listening on a remote port and free the listener + * Toss out any pending (un-accept()ed) connections + * + * Return 0 on success, LIBSSH2_ERROR_EAGAIN if would block, -1 on error + */ +int _libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener); + #endif /* __LIBSSH2_CHANNEL_H */ diff --git a/src/kex.c b/src/kex.c index d0767ca..09a6dd1 100644 --- a/src/kex.c +++ b/src/kex.c @@ -1032,7 +1032,7 @@ static int kexinit(LIBSSH2_SESSION * session) *(s++) = SSH_MSG_KEXINIT; - libssh2_random(s, 16); + _libssh2_random(s, 16); s += 16; /* Ennumerating through these lists twice is probably (certainly?) @@ -1630,14 +1630,14 @@ static int kex_agree_methods(LIBSSH2_SESSION * session, unsigned char *data, -/* libssh2_kex_exchange +/* _libssh2_kex_exchange * Exchange keys * Returns 0 on success, non-zero on failure * * Returns some errors without _libssh2_error() */ int -libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange, +_libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange, key_exchange_state_t * key_state) { int rc = 0; diff --git a/src/knownhost.c b/src/knownhost.c index e14dc1a..ad0fc73 100644 --- a/src/knownhost.c +++ b/src/knownhost.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009 by Daniel Stenberg + * Copyright (c) 2009, 2010 by Daniel Stenberg * All rights reserved. * * Redistribution and use in source and binary forms, @@ -638,10 +638,10 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts, memcpy(hostbuf, sep, seplen); hostbuf[seplen]=0; - rc = libssh2_knownhost_addc(hosts, hostbuf, salt, key, keylen, - comment, commentlen, - type | LIBSSH2_KNOWNHOST_KEYENC_BASE64, - NULL); + rc = knownhost_add(hosts, hostbuf, salt, key, keylen, + comment, commentlen, + type | LIBSSH2_KNOWNHOST_KEYENC_BASE64, + NULL); if(rc) return rc; } @@ -651,10 +651,10 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts, memcpy(hostbuf, host, hostlen); hostbuf[hostlen]=0; - rc = libssh2_knownhost_addc(hosts, hostbuf, salt, key, keylen, comment, - commentlen, - type | LIBSSH2_KNOWNHOST_KEYENC_BASE64, - NULL); + rc = knownhost_add(hosts, hostbuf, salt, key, keylen, comment, + commentlen, + type | LIBSSH2_KNOWNHOST_KEYENC_BASE64, + NULL); return rc; } diff --git a/src/libgcrypt.h b/src/libgcrypt.h index 2a48270..290e200 100644 --- a/src/libgcrypt.h +++ b/src/libgcrypt.h @@ -56,7 +56,7 @@ #define MD5_DIGEST_LENGTH 16 #define SHA_DIGEST_LENGTH 20 -#define libssh2_random(buf, len) \ +#define _libssh2_random(buf, len) \ (gcry_randomize ((buf), (len), GCRY_STRONG_RANDOM), 1) #define libssh2_sha1_ctx gcry_md_hd_t diff --git a/src/libssh2_priv.h b/src/libssh2_priv.h index b46db0c..f164def 100644 --- a/src/libssh2_priv.h +++ b/src/libssh2_priv.h @@ -1122,8 +1122,8 @@ ssize_t _libssh2_send(libssh2_socket_t socket, const void *buffer, size_t length waiting for more data to arrive */ -int libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange, - key_exchange_state_t * state); +int _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange, + key_exchange_state_t * state); /* Let crypt.c/hostkey.c expose their method structs */ const LIBSSH2_CRYPT_METHOD **libssh2_crypt_methods(void); diff --git a/src/openssl.h b/src/openssl.h index 5f0b292..8e35f9d 100644 --- a/src/openssl.h +++ b/src/openssl.h @@ -104,7 +104,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 EVP_MD_CTX #define libssh2_sha1_init(ctx) EVP_DigestInit(ctx, EVP_get_digestbyname("sha1")) diff --git a/src/packet.c b/src/packet.c index 1d90881..5518a30 100644 --- a/src/packet.c +++ b/src/packet.c @@ -903,7 +903,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, /* * The KEXINIT message has been added to the queue. The packAdd and - * readPack states need to be reset because libssh2_kex_exchange + * readPack states need to be reset because _libssh2_kex_exchange * (eventually) calls upon _libssh2_transport_read to read the rest of * the key exchange conversation. */ @@ -923,10 +923,9 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data, * If there was a key reexchange failure, let's just hope we didn't * send NEWKEYS yet, otherwise remote will drop us like a rock */ - rc = libssh2_kex_exchange(session, 1, &session->startup_key_state); - if (rc == LIBSSH2_ERROR_EAGAIN) { + rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state); + if (rc == LIBSSH2_ERROR_EAGAIN) return rc; - } } session->packAdd_state = libssh2_NB_state_idle; diff --git a/src/publickey.c b/src/publickey.c index be19348..e685195 100644 --- a/src/publickey.c +++ b/src/publickey.c @@ -487,7 +487,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session) err_exit: session->pkeyInit_state = libssh2_NB_state_sent4; if (session->pkeyInit_channel) { - rc = libssh2_channel_close(session->pkeyInit_channel); + rc = _libssh2_channel_close(session->pkeyInit_channel); if (rc == LIBSSH2_ERROR_EAGAIN) { _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block closing channel"); @@ -1011,7 +1011,7 @@ libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY * pkey) pkey->listFetch_data = NULL; } - rc = libssh2_channel_free(pkey->channel); + rc = _libssh2_channel_free(pkey->channel); if (rc == LIBSSH2_ERROR_EAGAIN) return rc; diff --git a/src/scp.c b/src/scp.c index 6d97f0b..10a566c 100644 --- a/src/scp.c +++ b/src/scp.c @@ -45,7 +45,7 @@ /* Max. length of a quoted string after libssh2_shell_quotearg() processing */ -#define libssh2_shell_quotedsize(s) (3 * strlen(s) + 2) +#define _libssh2_shell_quotedsize(s) (3 * strlen(s) + 2) /* This function quotes a string in a way suitable to be used with a @@ -123,8 +123,8 @@ */ static unsigned -libssh2_shell_quotearg(const char *path, unsigned char *buf, - unsigned bufsize) +shell_quotearg(const char *path, unsigned char *buf, + unsigned bufsize) { const char *src; unsigned char *dst, *endp; @@ -280,7 +280,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb) session->scpRecv_atime = 0; session->scpRecv_command_len = - libssh2_shell_quotedsize(path) + sizeof("scp -f ") + (sb?1:0); + _libssh2_shell_quotedsize(path) + sizeof("scp -f ") + (sb?1:0); session->scpRecv_command = LIBSSH2_ALLOC(session, session->scpRecv_command_len); @@ -297,9 +297,9 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb) cmd_len = strlen((char *)session->scpRecv_command); - (void) libssh2_shell_quotearg(path, - &session->scpRecv_command[cmd_len], - session->scpRecv_command_len - cmd_len); + (void) shell_quotearg(path, + &session->scpRecv_command[cmd_len], + session->scpRecv_command_len - cmd_len); _libssh2_debug(session, LIBSSH2_TRACE_SCP, @@ -311,11 +311,11 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb) if (session->scpRecv_state == libssh2_NB_state_created) { /* Allocate a channel */ session->scpRecv_channel = - libssh2_channel_open_ex(session, "session", - sizeof("session") - 1, - LIBSSH2_CHANNEL_WINDOW_DEFAULT, - LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, - 0); + _libssh2_channel_open(session, "session", + sizeof("session") - 1, + LIBSSH2_CHANNEL_WINDOW_DEFAULT, + LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, + 0); if (!session->scpRecv_channel) { if (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) { @@ -335,10 +335,10 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb) if (session->scpRecv_state == libssh2_NB_state_sent) { /* Request SCP for the desired file */ - rc = libssh2_channel_process_startup(session->scpRecv_channel, "exec", - sizeof("exec") - 1, - (char *) session->scpRecv_command, - session->scpRecv_command_len); + rc = _libssh2_channel_process_startup(session->scpRecv_channel, "exec", + sizeof("exec") - 1, + (char *) session->scpRecv_command, + session->scpRecv_command_len); if (rc == LIBSSH2_ERROR_EAGAIN) { _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block requesting SCP startup"); @@ -783,7 +783,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode, if (session->scpSend_state == libssh2_NB_state_idle) { session->scpSend_command_len = - libssh2_shell_quotedsize(path) + sizeof("scp -t ") + + _libssh2_shell_quotedsize(path) + sizeof("scp -t ") + ((mtime || atime)?1:0); session->scpSend_command = @@ -799,9 +799,9 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode, cmd_len = strlen((char *)session->scpSend_command); - (void)libssh2_shell_quotearg(path, - &session->scpSend_command[cmd_len], - session->scpSend_command_len - cmd_len); + (void)shell_quotearg(path, + &session->scpSend_command[cmd_len], + session->scpSend_command_len - cmd_len); session->scpSend_command[session->scpSend_command_len - 1] = '\0'; @@ -814,9 +814,9 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode, if (session->scpSend_state == libssh2_NB_state_created) { session->scpSend_channel = - libssh2_channel_open_ex(session, "session", sizeof("session") - 1, - LIBSSH2_CHANNEL_WINDOW_DEFAULT, - LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0); + _libssh2_channel_open(session, "session", sizeof("session") - 1, + LIBSSH2_CHANNEL_WINDOW_DEFAULT, + LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0); if (!session->scpSend_channel) { if (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) { /* previous call set libssh2_session_last_error(), pass it @@ -837,10 +837,10 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode, if (session->scpSend_state == libssh2_NB_state_sent) { /* Request SCP for the desired file */ - rc = libssh2_channel_process_startup(session->scpSend_channel, "exec", - sizeof("exec") - 1, - (char *) session->scpSend_command, - session->scpSend_command_len); + rc = _libssh2_channel_process_startup(session->scpSend_channel, "exec", + sizeof("exec") - 1, + (char *) session->scpSend_command, + session->scpSend_command_len); if (rc == LIBSSH2_ERROR_EAGAIN) { _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block requesting SCP startup"); diff --git a/src/session.c b/src/session.c index a96d3b3..4381b64 100644 --- a/src/session.c +++ b/src/session.c @@ -54,6 +54,7 @@ #include "transport.h" #include "session.h" +#include "channel.h" /* libssh2_default_alloc */ @@ -631,11 +632,10 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock) } if (session->startup_state == libssh2_NB_state_sent1) { - rc = libssh2_kex_exchange(session, 0, &session->startup_key_state); - if (rc) { + rc = _libssh2_kex_exchange(session, 0, &session->startup_key_state); + if (rc) return _libssh2_error(session, rc, "Unable to exchange encryption keys"); - } session->startup_state = libssh2_NB_state_sent2; } @@ -740,7 +740,7 @@ session_free(LIBSSH2_SESSION *session) if (session->free_state == libssh2_NB_state_created) { while ((ch = _libssh2_list_first(&session->channels))) { - rc = libssh2_channel_free(ch); + rc = _libssh2_channel_free(ch); if (rc == LIBSSH2_ERROR_EAGAIN) return rc; } @@ -750,7 +750,7 @@ session_free(LIBSSH2_SESSION *session) if (session->state == libssh2_NB_state_sent) { while ((l = _libssh2_list_first(&session->listeners))) { - rc = libssh2_channel_forward_cancel(l); + rc = _libssh2_channel_forward_cancel(l); if (rc == LIBSSH2_ERROR_EAGAIN) return rc; } diff --git a/src/transport.c b/src/transport.c index f97c3fc..374c09b 100644 --- a/src/transport.c +++ b/src/transport.c @@ -313,7 +313,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session) */ _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the" " key re-exchange"); - rc = libssh2_kex_exchange(session, 1, &session->startup_key_state); + rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state); if (rc) return rc; } @@ -797,7 +797,7 @@ _libssh2_transport_write(LIBSSH2_SESSION * session, unsigned char *data, /* copy the payload data */ memcpy(p->outbuf + 5, data, data_len); /* fill the padding area with random junk */ - libssh2_random(p->outbuf + 5 + data_len, padding_length); + _libssh2_random(p->outbuf + 5 + data_len, padding_length); if (free_data) { LIBSSH2_FREE(session, data); } diff --git a/src/userauth.c b/src/userauth.c index b9e0f79..7934535 100644 --- a/src/userauth.c +++ b/src/userauth.c @@ -50,6 +50,7 @@ #include "transport.h" #include "session.h" +#include "userauth.h" /* libssh2_userauth_list * @@ -857,14 +858,14 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION *session, -static int -userauth_publickey(LIBSSH2_SESSION *session, - const char *username, - unsigned int username_len, - const unsigned char *pubkeydata, - unsigned long pubkeydata_len, - LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC((*sign_callback)), - void *abstract) +int +_libssh2_userauth_publickey(LIBSSH2_SESSION *session, + const char *username, + unsigned int username_len, + const unsigned char *pubkeydata, + unsigned long pubkeydata_len, + LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC((*sign_callback)), + void *abstract) { unsigned char reply_codes[4] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, @@ -1186,9 +1187,9 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session, return rc; } - rc = userauth_publickey(session, username, username_len, - pubkeydata, pubkeydata_len, - sign_fromfile, &abstract); + rc = _libssh2_userauth_publickey(session, username, username_len, + pubkeydata, pubkeydata_len, + sign_fromfile, &abstract); if(pubkeydata) LIBSSH2_FREE(session, pubkeydata); @@ -1233,9 +1234,9 @@ libssh2_userauth_publickey(LIBSSH2_SESSION *session, { int rc; BLOCK_ADJUST(rc, session, - userauth_publickey(session, user, strlen(user), - pubkeydata, pubkeydata_len, - sign_callback, abstract)); + _libssh2_userauth_publickey(session, user, strlen(user), + pubkeydata, pubkeydata_len, + sign_callback, abstract)); return rc; } diff --git a/src/userauth.h b/src/userauth.h new file mode 100644 index 0000000..c0442ae --- /dev/null +++ b/src/userauth.h @@ -0,0 +1,50 @@ +#ifndef LIBSSH2_USERAUTH_H +#define LIBSSH2_USERAUTH_H +/* Copyright (c) 2004-2007, Sara Golemon + * Copyright (c) 2009-2010 by Daniel Stenberg + * All rights reserved. + * + * Redistribution and use in source and binary forms, + * with or without modification, are permitted provided + * that the following conditions are met: + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * Neither the name of the copyright holder nor the names + * of any other contributors may be used to endorse or + * promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + */ + +int +_libssh2_userauth_publickey(LIBSSH2_SESSION *session, + const char *username, + unsigned int username_len, + const unsigned char *pubkeydata, + unsigned long pubkeydata_len, + LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC((*sign_callback)), + void *abstract); + +#endif /* LIBSSH2_USERAUTH_H */