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.
2010-04-24 21:14:16 +02:00 · 2010-04-24 21:14:16 +02:00 · 71fb9cc93e
--- 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,7 +717,8 @@ libssh2_agent_userauth(LIBSSH2_AGENT *agent,
        memset(&agent->transctx, 0, sizeof agent->transctx);
        agent->identity = identity->node;
    }
-    return libssh2_userauth_publickey(agent->session, username,
+    return _libssh2_userauth_publickey(agent->session, username,
+                                       strlen(username),
                                       identity->blob,
                                       identity->blob_len,
                                       agent_sign,
--- a/src/channel.c
+++ b/src/channel.c
@ -372,16 +372,13 @@ channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host,
    }

    channel =
-        libssh2_channel_open_ex(session, "direct-tcpip",
+        _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);

-    /* by default we set (keep?) idle state... */
-    session->direct_state = libssh2_NB_state_idle;
-
    if (!channel &&
        libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
        /* The error code is still set to LIBSSH2_ERROR_EAGAIN, set our state
@ -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;
--- 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 */

--- 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;
--- 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,7 +638,7 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
        memcpy(hostbuf, sep, seplen);
        hostbuf[seplen]=0;

-        rc = libssh2_knownhost_addc(hosts, hostbuf, salt, key, keylen,
+        rc = knownhost_add(hosts, hostbuf, salt, key, keylen,
                           comment, commentlen,
                           type | LIBSSH2_KNOWNHOST_KEYENC_BASE64,
                           NULL);
@ -651,7 +651,7 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
    memcpy(hostbuf, host, hostlen);
    hostbuf[hostlen]=0;

-    rc = libssh2_knownhost_addc(hosts, hostbuf, salt, key, keylen, comment,
+    rc = knownhost_add(hosts, hostbuf, salt, key, keylen, comment,
                       commentlen,
                       type | LIBSSH2_KNOWNHOST_KEYENC_BASE64,
                       NULL);
--- 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
--- a/src/libssh2_priv.h
+++ b/src/libssh2_priv.h
@ -1122,7 +1122,7 @@ 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,
+int _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
                          key_exchange_state_t * state);

 /* Let crypt.c/hostkey.c expose their method structs */
--- 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"))
--- 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,11 +923,10 @@ _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;
    return 0;
--- 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;

--- 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,7 +123,7 @@
 */

 static unsigned
-libssh2_shell_quotearg(const char *path, unsigned char *buf,
+shell_quotearg(const char *path, unsigned char *buf,
               unsigned bufsize)
 {
    const char *src;
@ -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,7 +297,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb)

        cmd_len = strlen((char *)session->scpRecv_command);

-        (void) libssh2_shell_quotearg(path,
+        (void) shell_quotearg(path,
                              &session->scpRecv_command[cmd_len],
                              session->scpRecv_command_len - cmd_len);

@ -311,7 +311,7 @@ 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",
+            _libssh2_channel_open(session, "session",
                                  sizeof("session") - 1,
                                  LIBSSH2_CHANNEL_WINDOW_DEFAULT,
                                  LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL,
@ -335,7 +335,7 @@ 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",
+        rc = _libssh2_channel_process_startup(session->scpRecv_channel, "exec",
                                              sizeof("exec") - 1,
                                              (char *) session->scpRecv_command,
                                              session->scpRecv_command_len);
@ -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,7 +799,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,

        cmd_len = strlen((char *)session->scpSend_command);

-        (void)libssh2_shell_quotearg(path,
+        (void)shell_quotearg(path,
                             &session->scpSend_command[cmd_len],
                             session->scpSend_command_len - cmd_len);

@ -814,7 +814,7 @@ 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_open(session, "session", sizeof("session") - 1,
                                  LIBSSH2_CHANNEL_WINDOW_DEFAULT,
                                  LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0);
        if (!session->scpSend_channel) {
@ -837,7 +837,7 @@ 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",
+        rc = _libssh2_channel_process_startup(session->scpSend_channel, "exec",
                                              sizeof("exec") - 1,
                                              (char *) session->scpSend_command,
                                              session->scpSend_command_len);
--- 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;
        }
--- 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);
    }
--- 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,8 +858,8 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION *session,



-static int
-userauth_publickey(LIBSSH2_SESSION *session,
+int
+_libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                            const char *username,
                            unsigned int username_len,
                            const unsigned char *pubkeydata,
@ -1186,7 +1187,7 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session,
            return rc;
    }

-    rc = userauth_publickey(session, username, username_len,
+    rc = _libssh2_userauth_publickey(session, username, username_len,
                                     pubkeydata, pubkeydata_len,
                                     sign_fromfile, &abstract);
    if(pubkeydata)
@ -1233,7 +1234,7 @@ libssh2_userauth_publickey(LIBSSH2_SESSION *session,
 {
    int rc;
    BLOCK_ADJUST(rc, session,
-                 userauth_publickey(session, user, strlen(user),
+                 _libssh2_userauth_publickey(session, user, strlen(user),
                                             pubkeydata, pubkeydata_len,
                                             sign_callback, abstract));
    return rc;
--- a/src/userauth.h
+++ b/src/userauth.h
@ -0,0 +1,50 @@
+#ifndef LIBSSH2_USERAUTH_H
+#define LIBSSH2_USERAUTH_H
+/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
+ * 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 */