static CURLcode ssh_setup_connection(struct Curl_easy *data,
struct connectdata *conn);
static void ssh_attach(struct Curl_easy *data, struct connectdata *conn);
-static int sshc_cleanup(struct ssh_conn *sshc, struct Curl_easy *data,
- bool block);
+static CURLcode sshc_cleanup(struct ssh_conn *sshc, struct Curl_easy *data,
+ bool block);
/*
* SCP protocol handler.
*/
FALLTHROUGH();
case CURLKHSTAT_DEFER:
/* DEFER means bail out but keep the SSH_HOSTKEY state */
- result = sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
+ result = CURLE_PEER_FAILED_VERIFICATION;
break;
case CURLKHSTAT_FINE_REPLACE:
/* remove old host+key that does not match */
"Denied establishing ssh session: sha256 fingerprint "
"not available");
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
- return sshc->actualcode;
+ return CURLE_PEER_FAILED_VERIFICATION;
}
/* The length of fingerprint is 32 bytes for SHA256.
if(curlx_base64_encode(fingerprint, 32, &fingerprint_b64,
&fingerprint_b64_len) != CURLE_OK) {
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
- return sshc->actualcode;
+ return CURLE_PEER_FAILED_VERIFICATION;
}
if(!fingerprint_b64) {
failf(data, "sha256 fingerprint could not be encoded");
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
- return sshc->actualcode;
+ return CURLE_PEER_FAILED_VERIFICATION;
}
infof(data, "SSH SHA256 fingerprint: %s", fingerprint_b64);
"Remote %s is not equal to %s", fingerprint_b64, pubkey_sha256);
free(fingerprint_b64);
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
- return sshc->actualcode;
+ return CURLE_PEER_FAILED_VERIFICATION;
}
free(fingerprint_b64);
"not available");
}
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
- return sshc->actualcode;
+ return CURLE_PEER_FAILED_VERIFICATION;
}
infof(data, "MD5 checksum match");
}
Curl_set_in_callback(data, FALSE);
if(rc!= CURLKHMATCH_OK) {
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
- return sshc->actualcode;
+ return CURLE_PEER_FAILED_VERIFICATION;
}
}
else {
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
- return sshc->actualcode;
+ return CURLE_PEER_FAILED_VERIFICATION;
}
return CURLE_OK;
}
LIBSSH2_SFTP_OPENFILE);
if(!sshc->sftp_handle) {
+ CURLcode result;
unsigned long sftperr;
int rc = libssh2_session_last_errno(sshc->ssh_session);
if(sshc->secondCreateDirs) {
myssh_state(data, sshc, SSH_SFTP_CLOSE);
- sshc->actualcode = sftperr != LIBSSH2_FX_OK ?
- sftp_libssh2_error_to_CURLE(sftperr) : CURLE_SSH;
failf(data, "Creating the dir/file failed: %s",
sftp_libssh2_strerror(sftperr));
- return CURLE_OK;
+ return sftp_libssh2_error_to_CURLE(sftperr);
}
if(((sftperr == LIBSSH2_FX_NO_SUCH_FILE) ||
(sftperr == LIBSSH2_FX_FAILURE) ||
return CURLE_OK;
}
myssh_state(data, sshc, SSH_SFTP_CLOSE);
- sshc->actualcode = sftperr != LIBSSH2_FX_OK ?
- sftp_libssh2_error_to_CURLE(sftperr) : CURLE_SSH;
- if(!sshc->actualcode) {
+ result = sftp_libssh2_error_to_CURLE(sftperr);
+ if(!result) {
/* Sometimes, for some reason libssh2_sftp_last_error() returns zero
even though libssh2_sftp_open() failed previously! We need to
work around that! */
- sshc->actualcode = CURLE_SSH;
+ result = CURLE_SSH;
sftperr = LIBSSH2_FX_OK;
}
failf(data, "Upload failed: %s (%lu/%d)",
sftperr != LIBSSH2_FX_OK ?
sftp_libssh2_strerror(sftperr) : "ssh error",
sftperr, rc);
- return sshc->actualcode;
+ return result;
}
/* If we have a restart point then we need to seek to the correct
/* make sure that this does not collide with an actual libssh2 error code */
#define ERROR_LIBBSH2 1
-static int ssh_state_pkey_init(struct Curl_easy *data,
+static CURLcode ssh_state_pkey_init(struct Curl_easy *data,
struct ssh_conn *sshc)
{
/*
Curl_safefree(sshc->rsa);
Curl_safefree(sshc->rsa_pub);
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_OUT_OF_MEMORY;
- return ERROR_LIBBSH2;
+ return CURLE_OUT_OF_MEMORY;
}
sshc->passphrase = data->set.ssl.key_passwd;
}
else {
unsigned long sftperr = libssh2_sftp_last_error(sshc->sftp_session);
- result = sftp_libssh2_error_to_CURLE(sftperr);
- sshc->actualcode = result ? result : CURLE_SSH;
+ result = sftperr ? sftp_libssh2_error_to_CURLE(sftperr) : CURLE_SSH;
failf(data, "Could not open remote file for reading: %s :: %d",
sftp_libssh2_strerror(sftperr),
libssh2_session_last_errno(sshc->ssh_session));
return result;
}
-static int ssh_state_init(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_init(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
CURLcode result;
sshc->secondCreateDirs = 0;
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = CURLE_OK;
/* Set libssh2 to non-blocking, since everything internally is
non-blocking */
libssh2_session_set_blocking(sshc->ssh_session, 0);
result = ssh_force_knownhost_key_type(data, sshc);
- if(result) {
+ if(result)
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = result;
- return ERROR_LIBBSH2;
- }
-
- myssh_state(data, sshc, SSH_S_STARTUP);
- return 0;
+ else
+ myssh_state(data, sshc, SSH_S_STARTUP);
+ return result;
}
-static int ssh_state_startup(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_startup(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
struct connectdata *conn = data->conn;
int rc = libssh2_session_handshake(sshc->ssh_session,
conn->sock[FIRSTSOCKET]);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc) {
char *err_msg = NULL;
(void)libssh2_session_last_error(sshc->ssh_session, &err_msg, NULL, 0);
failf(data, "Failure establishing ssh session: %d, %s", rc, err_msg);
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_FAILED_INIT;
- return rc;
+ return CURLE_FAILED_INIT;
}
myssh_state(data, sshc, SSH_HOSTKEY);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_hostkey(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_hostkey(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
/*
* Before we authenticate we should check the hostkey's fingerprint
* whatever) is up to us.
*/
CURLcode result = ssh_check_fingerprint(data, sshc);
- if(!result) {
+ if(!result)
myssh_state(data, sshc, SSH_AUTHLIST);
- return 0;
- }
- return ERROR_LIBBSH2;
+ return result;
}
-static int ssh_state_authlist(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_authlist(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
/*
* Figure out authentication methods
sshc->authed = TRUE;
infof(data, "SSH user accepted with no authentication");
myssh_state(data, sshc, SSH_AUTH_DONE);
- return 0;
+ return CURLE_OK;
}
rc = libssh2_session_last_errno(sshc->ssh_session);
if(rc == LIBSSH2_ERROR_EAGAIN)
- rc = LIBSSH2_ERROR_EAGAIN;
- else {
- myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = libssh2_session_error_to_CURLE(rc);
- }
- return rc;
+ return CURLE_AGAIN;
+
+ myssh_state(data, sshc, SSH_SESSION_FREE);
+ return libssh2_session_error_to_CURLE(rc);
}
infof(data, "SSH authentication methods available: %s",
sshc->authlist);
myssh_state(data, sshc, SSH_AUTH_PKEY_INIT);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_auth_pkey(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_auth_pkey(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
/* The function below checks if the files exists, no need to stat() here.
*/
sshc->rsa_pub,
sshc->rsa, sshc->passphrase);
if(rc == LIBSSH2_ERROR_EAGAIN)
- return rc;
+ return CURLE_AGAIN;
Curl_safefree(sshc->rsa_pub);
Curl_safefree(sshc->rsa);
}
infof(data, "SSH public key authentication failed: %s", err_msg);
myssh_state(data, sshc, SSH_AUTH_PASS_INIT);
- rc = 0; /* clear rc and continue */
}
- return rc;
+ return CURLE_OK;
}
-static int ssh_state_auth_pass_init(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_auth_pass_init(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
if((data->set.ssh_auth_types & CURLSSH_AUTH_PASSWORD) &&
(strstr(sshc->authlist, "password") != NULL)) {
else {
myssh_state(data, sshc, SSH_AUTH_HOST_INIT);
}
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_auth_pass(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_auth_pass(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
struct connectdata *conn = data->conn;
int rc =
curlx_uztoui(strlen(conn->passwd)),
NULL);
if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
+ return CURLE_AGAIN;
}
if(rc == 0) {
sshc->authed = TRUE;
}
else {
myssh_state(data, sshc, SSH_AUTH_HOST_INIT);
- rc = 0; /* clear rc and continue */
}
- return rc;
+ return CURLE_OK;
}
-static int ssh_state_auth_host_init(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_auth_host_init(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
if((data->set.ssh_auth_types & CURLSSH_AUTH_HOST) &&
(strstr(sshc->authlist, "hostbased") != NULL)) {
else {
myssh_state(data, sshc, SSH_AUTH_AGENT_INIT);
}
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_auth_agent_init(struct Curl_easy *data,
+static CURLcode ssh_state_auth_agent_init(struct Curl_easy *data,
struct ssh_conn *sshc)
{
int rc = 0;
infof(data, "Could not create agent object");
myssh_state(data, sshc, SSH_AUTH_KEY_INIT);
- return 0;
+ return CURLE_OK;
}
}
rc = libssh2_agent_connect(sshc->ssh_agent);
if(rc == LIBSSH2_ERROR_EAGAIN)
- return rc;
+ return CURLE_AGAIN;
if(rc < 0) {
infof(data, "Failure connecting to agent");
myssh_state(data, sshc, SSH_AUTH_KEY_INIT);
- rc = 0; /* clear rc and continue */
}
else {
myssh_state(data, sshc, SSH_AUTH_AGENT_LIST);
}
else
myssh_state(data, sshc, SSH_AUTH_KEY_INIT);
- return rc;
+ return CURLE_OK;
}
-static int ssh_state_auth_agent_list(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_auth_agent_list(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
int rc = libssh2_agent_list_identities(sshc->ssh_agent);
if(rc == LIBSSH2_ERROR_EAGAIN)
- return rc;
+ return CURLE_AGAIN;
if(rc < 0) {
infof(data, "Failure requesting identities to agent");
myssh_state(data, sshc, SSH_AUTH_KEY_INIT);
- rc = 0; /* clear rc and continue */
}
else {
myssh_state(data, sshc, SSH_AUTH_AGENT);
sshc->sshagent_prev_identity = NULL;
}
- return rc;
+ return CURLE_OK;
}
-static int ssh_state_auth_agent(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_auth_agent(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
/* as prev_identity evolves only after an identity user auth finished we
can safely request it again as long as EAGAIN is returned here or by
&sshc->sshagent_identity,
sshc->sshagent_prev_identity);
if(rc == LIBSSH2_ERROR_EAGAIN)
- return rc;
+ return CURLE_AGAIN;
if(rc == 0) {
struct connectdata *conn = data->conn;
/* tried and failed? go to next identity */
sshc->sshagent_prev_identity = sshc->sshagent_identity;
}
- return rc;
+ return CURLE_OK;
}
}
}
else {
myssh_state(data, sshc, SSH_AUTH_KEY_INIT);
- rc = 0; /* clear rc and continue */
}
- return rc;
+ return CURLE_OK;
}
-static int ssh_state_auth_key_init(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_auth_key_init(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
if((data->set.ssh_auth_types & CURLSSH_AUTH_KEYBOARD)
&& (strstr(sshc->authlist, "keyboard-interactive") != NULL)) {
else {
myssh_state(data, sshc, SSH_AUTH_DONE);
}
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_auth_key(struct Curl_easy *data,
+static CURLcode ssh_state_auth_key(struct Curl_easy *data,
struct ssh_conn *sshc)
{
/* Authentication failed. Continue with keyboard-interactive now. */
curlx_uztoui(
strlen(conn->user)),
&kbd_callback);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc == 0) {
sshc->authed = TRUE;
infof(data, "Initialized keyboard interactive authentication");
+ myssh_state(data, sshc, SSH_AUTH_DONE);
+ return CURLE_OK;
}
- myssh_state(data, sshc, SSH_AUTH_DONE);
- return rc;
+ return CURLE_LOGIN_DENIED;
}
-static int ssh_state_auth_done(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_auth_done(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
struct connectdata *conn = data->conn;
if(!sshc->authed) {
failf(data, "Authentication failure");
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_LOGIN_DENIED;
- return ERROR_LIBBSH2;
+ return CURLE_LOGIN_DENIED;
}
/*
if(conn->handler->protocol == CURLPROTO_SFTP) {
myssh_state(data, sshc, SSH_SFTP_INIT);
- return 0;
+ return CURLE_OK;
}
infof(data, "SSH CONNECT phase done");
myssh_state(data, sshc, SSH_STOP);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_init(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_sftp_init(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
/*
* Start the libssh2 sftp session
char *err_msg = NULL;
if(libssh2_session_last_errno(sshc->ssh_session) ==
LIBSSH2_ERROR_EAGAIN)
- return LIBSSH2_ERROR_EAGAIN;
+ return CURLE_AGAIN;
(void)libssh2_session_last_error(sshc->ssh_session,
&err_msg, NULL, 0);
failf(data, "Failure initializing sftp session: %s", err_msg);
myssh_state(data, sshc, SSH_SESSION_FREE);
- sshc->actualcode = CURLE_FAILED_INIT;
- return ERROR_LIBBSH2;
+ return CURLE_FAILED_INIT;
}
myssh_state(data, sshc, SSH_SFTP_REALPATH);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_realpath(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_sftp_realpath(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
/*
* Get the "home" directory
".", curlx_uztoui(strlen(".")),
sshp->readdir_filename, CURL_PATH_MAX,
LIBSSH2_SFTP_REALPATH);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc > 0) {
/* It seems that this string is not always NULL terminated */
sshp->readdir_filename[rc] = '\0';
sshc->homedir = strdup(sshp->readdir_filename);
if(!sshc->homedir) {
myssh_state(data, sshc, SSH_SFTP_CLOSE);
- sshc->actualcode = CURLE_OUT_OF_MEMORY;
- return ERROR_LIBBSH2;
+ return CURLE_OUT_OF_MEMORY;
}
free(data->state.most_recent_ftp_entrypath);
data->state.most_recent_ftp_entrypath = strdup(sshc->homedir);
if(!data->state.most_recent_ftp_entrypath)
- return ERROR_LIBBSH2;
+ return CURLE_OUT_OF_MEMORY;
}
else {
/* Return the error type */
/* in this case, the error was not in the SFTP level but for example
a time-out or similar */
result = CURLE_SSH;
- sshc->actualcode = result;
DEBUGF(infof(data, "error = %lu makes libcurl = %d",
sftperr, (int)result));
myssh_state(data, sshc, SSH_STOP);
- return 0;
+ return result;
}
/* This is the last step in the SFTP connect phase. Do note that while
working path will not. */
DEBUGF(infof(data, "SSH CONNECT phase done"));
myssh_state(data, sshc, SSH_STOP);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_quote_init(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_sftp_quote_init(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
CURLcode result = Curl_getworkingpath(data, sshc->homedir, &sshp->path);
if(result) {
- sshc->actualcode = result;
myssh_state(data, sshc, SSH_STOP);
- return ERROR_LIBBSH2;
+ return result;
}
if(data->set.quote) {
else {
myssh_state(data, sshc, SSH_SFTP_GETINFO);
}
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_postquote_init(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_sftp_postquote_init(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
if(data->set.postquote) {
infof(data, "Sending quote commands");
else {
myssh_state(data, sshc, SSH_STOP);
}
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_quote(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_sftp_quote(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
/* Send quote commands */
CURLcode result = sftp_quote(data, sshc, sshp);
if(result) {
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = result;
}
- return 0;
+ return result;
}
-static int ssh_state_sftp_next_quote(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_sftp_next_quote(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
Curl_safefree(sshc->quote_path1);
Curl_safefree(sshc->quote_path2);
myssh_state(data, sshc, SSH_SFTP_GETINFO);
}
}
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_quote_stat(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp,
- bool *blockp)
+static CURLcode ssh_state_sftp_quote_stat(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp,
+ bool *blockp)
{
CURLcode result = sftp_quote_stat(data, sshc, sshp, blockp);
if(result) {
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = result;
- return ERROR_LIBBSH2;
}
- return 0;
+ return result;
}
-static int ssh_state_sftp_quote_setstat(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_sftp_quote_setstat(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
int rc =
libssh2_sftp_stat_ex(sshc->sftp_session, sshc->quote_path2,
curlx_uztoui(strlen(sshc->quote_path2)),
LIBSSH2_SFTP_SETSTAT,
&sshp->quote_attrs);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc && !sshc->acceptfail) {
unsigned long sftperr = libssh2_sftp_last_error(sshc->sftp_session);
Curl_safefree(sshc->quote_path1);
sftp_libssh2_strerror(sftperr));
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = CURLE_QUOTE_ERROR;
- return ERROR_LIBBSH2;
+ return CURLE_QUOTE_ERROR;
}
myssh_state(data, sshc, SSH_SFTP_NEXT_QUOTE);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_quote_symlink(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_sftp_quote_symlink(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
int rc =
libssh2_sftp_symlink_ex(sshc->sftp_session, sshc->quote_path1,
sshc->quote_path2,
curlx_uztoui(strlen(sshc->quote_path2)),
LIBSSH2_SFTP_SYMLINK);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc && !sshc->acceptfail) {
unsigned long sftperr = libssh2_sftp_last_error(sshc->sftp_session);
Curl_safefree(sshc->quote_path1);
sftp_libssh2_strerror(sftperr));
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = CURLE_QUOTE_ERROR;
- return ERROR_LIBBSH2;
+ return CURLE_QUOTE_ERROR;
}
myssh_state(data, sshc, SSH_SFTP_NEXT_QUOTE);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_quote_mkdir(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_sftp_quote_mkdir(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
int rc = libssh2_sftp_mkdir_ex(sshc->sftp_session, sshc->quote_path1,
curlx_uztoui(strlen(sshc->quote_path1)),
(long)data->set.new_directory_perms);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc && !sshc->acceptfail) {
unsigned long sftperr = libssh2_sftp_last_error(sshc->sftp_session);
Curl_safefree(sshc->quote_path1);
sftp_libssh2_strerror(sftperr));
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = CURLE_QUOTE_ERROR;
- return ERROR_LIBBSH2;
+ return CURLE_QUOTE_ERROR;
}
myssh_state(data, sshc, SSH_SFTP_NEXT_QUOTE);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_quote_rename(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_sftp_quote_rename(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
int rc =
libssh2_sftp_rename_ex(sshc->sftp_session, sshc->quote_path1,
LIBSSH2_SFTP_RENAME_ATOMIC |
LIBSSH2_SFTP_RENAME_NATIVE);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc && !sshc->acceptfail) {
unsigned long sftperr = libssh2_sftp_last_error(sshc->sftp_session);
Curl_safefree(sshc->quote_path1);
sftp_libssh2_strerror(sftperr));
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = CURLE_QUOTE_ERROR;
- return ERROR_LIBBSH2;
+ return CURLE_QUOTE_ERROR;
}
myssh_state(data, sshc, SSH_SFTP_NEXT_QUOTE);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_quote_rmdir(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_sftp_quote_rmdir(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
int rc = libssh2_sftp_rmdir_ex(sshc->sftp_session, sshc->quote_path1,
curlx_uztoui(strlen(sshc->quote_path1)));
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc && !sshc->acceptfail) {
unsigned long sftperr = libssh2_sftp_last_error(sshc->sftp_session);
Curl_safefree(sshc->quote_path1);
sftp_libssh2_strerror(sftperr));
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = CURLE_QUOTE_ERROR;
- return ERROR_LIBBSH2;
+ return CURLE_QUOTE_ERROR;
}
myssh_state(data, sshc, SSH_SFTP_NEXT_QUOTE);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_quote_unlink(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_sftp_quote_unlink(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
int rc = libssh2_sftp_unlink_ex(sshc->sftp_session, sshc->quote_path1,
curlx_uztoui(strlen(sshc->quote_path1)));
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc && !sshc->acceptfail) {
unsigned long sftperr = libssh2_sftp_last_error(sshc->sftp_session);
Curl_safefree(sshc->quote_path1);
failf(data, "rm command failed: %s", sftp_libssh2_strerror(sftperr));
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = CURLE_QUOTE_ERROR;
- return ERROR_LIBBSH2;
+ return CURLE_QUOTE_ERROR;
}
myssh_state(data, sshc, SSH_SFTP_NEXT_QUOTE);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_quote_statvfs(struct Curl_easy *data,
+static CURLcode ssh_state_sftp_quote_statvfs(struct Curl_easy *data,
struct ssh_conn *sshc)
{
LIBSSH2_SFTP_STATVFS statvfs;
curlx_uztoui(strlen(sshc->quote_path1)),
&statvfs);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc && !sshc->acceptfail) {
unsigned long sftperr = libssh2_sftp_last_error(sshc->sftp_session);
Curl_safefree(sshc->quote_path1);
sftp_libssh2_strerror(sftperr));
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = CURLE_QUOTE_ERROR;
- return ERROR_LIBBSH2;
+ return CURLE_QUOTE_ERROR;
}
else if(rc == 0) {
#ifdef _MSC_VER
statvfs.f_fsid, statvfs.f_flag,
statvfs.f_namemax);
if(!tmp) {
- sshc->actualcode = CURLE_OUT_OF_MEMORY;
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- return ERROR_LIBBSH2;
+ return CURLE_OUT_OF_MEMORY;
}
result = Curl_client_write(data, CLIENTWRITE_HEADER, tmp, strlen(tmp));
if(result) {
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = result;
+ return result;
}
}
myssh_state(data, sshc, SSH_SFTP_NEXT_QUOTE);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_create_dirs_mkdir(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_sftp_create_dirs_mkdir(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
/* 'mode' - parameter is preliminary - default to 0644 */
int rc = libssh2_sftp_mkdir_ex(sshc->sftp_session, sshp->path,
curlx_uztoui(strlen(sshp->path)),
(long)data->set.new_directory_perms);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
*sshc->slash_pos = '/';
++sshc->slash_pos;
if(rc < 0) {
* permission was denied (creation might succeed further down the
* path) - retry on unspecific FAILURE also
*/
- CURLcode result;
unsigned long sftperr = libssh2_sftp_last_error(sshc->sftp_session);
if((sftperr != LIBSSH2_FX_FILE_ALREADY_EXISTS) &&
(sftperr != LIBSSH2_FX_FAILURE) &&
(sftperr != LIBSSH2_FX_PERMISSION_DENIED)) {
- result = sftp_libssh2_error_to_CURLE(sftperr);
myssh_state(data, sshc, SSH_SFTP_CLOSE);
- sshc->actualcode = result ? result : CURLE_SSH;
- return ERROR_LIBBSH2;
+ return sftp_libssh2_error_to_CURLE(sftperr);
}
- rc = 0; /* clear rc and continue */
}
myssh_state(data, sshc, SSH_SFTP_CREATE_DIRS);
- return rc;
+ return CURLE_OK;
}
-static int ssh_state_sftp_readdir_init(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_sftp_readdir_init(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
Curl_pgrsSetDownloadSize(data, -1);
if(data->req.no_body) {
myssh_state(data, sshc, SSH_STOP);
- return 0;
+ return CURLE_OK;
}
/*
0, 0, LIBSSH2_SFTP_OPENDIR);
if(!sshc->sftp_handle) {
unsigned long sftperr;
- CURLcode result;
- if(libssh2_session_last_errno(sshc->ssh_session) ==
- LIBSSH2_ERROR_EAGAIN) {
- return LIBSSH2_ERROR_EAGAIN;
- }
+ if(libssh2_session_last_errno(sshc->ssh_session) == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
sftperr = libssh2_sftp_last_error(sshc->sftp_session);
failf(data, "Could not open directory for reading: %s",
sftp_libssh2_strerror(sftperr));
myssh_state(data, sshc, SSH_SFTP_CLOSE);
- result = sftp_libssh2_error_to_CURLE(sftperr);
- sshc->actualcode = result ? result : CURLE_SSH;
- return ERROR_LIBBSH2;
+ return sftp_libssh2_error_to_CURLE(sftperr);
}
myssh_state(data, sshc, SSH_SFTP_READDIR);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_readdir_link(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_sftp_readdir_link(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
CURLcode result;
int rc =
curlx_dyn_len(&sshp->readdir_link),
sshp->readdir_filename,
CURL_PATH_MAX, LIBSSH2_SFTP_READLINK);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
curlx_dyn_free(&sshp->readdir_link);
/* append filename and extra output */
- result = curlx_dyn_addf(&sshp->readdir, " -> %s",
- sshp->readdir_filename);
-
- if(result) {
+ result = curlx_dyn_addf(&sshp->readdir, " -> %s", sshp->readdir_filename);
+ if(result)
myssh_state(data, sshc, SSH_SFTP_CLOSE);
- sshc->actualcode = result;
- return ERROR_LIBBSH2;
- }
-
- myssh_state(data, sshc, SSH_SFTP_READDIR_BOTTOM);
- return 0;
+ else
+ myssh_state(data, sshc, SSH_SFTP_READDIR_BOTTOM);
+ return result;
}
-static int ssh_state_scp_download_init(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_scp_download_init(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
curl_off_t bytecount;
char *err_msg = NULL;
if(libssh2_session_last_errno(sshc->ssh_session) ==
- LIBSSH2_ERROR_EAGAIN) {
- return LIBSSH2_ERROR_EAGAIN;
- }
+ LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
ssh_err = (int)(libssh2_session_last_error(sshc->ssh_session,
&err_msg, NULL, 0));
failf(data, "%s", err_msg);
myssh_state(data, sshc, SSH_SCP_CHANNEL_FREE);
- sshc->actualcode = libssh2_session_error_to_CURLE(ssh_err);
- return ERROR_LIBBSH2;
+ return libssh2_session_error_to_CURLE(ssh_err);
}
/* download data */
data->state.select_bits = CURL_CSELECT_IN;
myssh_state(data, sshc, SSH_STOP);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_close(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_sftp_close(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
int rc = 0;
if(sshc->sftp_handle) {
rc = libssh2_sftp_close(sshc->sftp_handle);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc < 0) {
char *err_msg = NULL;
(void)libssh2_session_last_error(sshc->ssh_session,
else
myssh_state(data, sshc, SSH_STOP);
- return rc;
+ return CURLE_OK;
}
-static int ssh_state_sftp_shutdown(struct Curl_easy *data,
+static CURLcode ssh_state_sftp_shutdown(struct Curl_easy *data,
struct ssh_conn *sshc)
{
/* during times we get here due to a broken transfer and then the
int rc = 0;
if(sshc->sftp_handle) {
rc = libssh2_sftp_close(sshc->sftp_handle);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc < 0) {
char *err_msg = NULL;
(void)libssh2_session_last_error(sshc->ssh_session, &err_msg,
}
if(sshc->sftp_session) {
rc = libssh2_sftp_shutdown(sshc->sftp_session);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc < 0) {
infof(data, "Failed to stop libssh2 sftp subsystem");
}
Curl_safefree(sshc->homedir);
myssh_state(data, sshc, SSH_SESSION_DISCONNECT);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_sftp_download_init(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_sftp_download_init(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
/*
* Work on getting the specified file
LIBSSH2_SFTP_OPENFILE);
if(!sshc->sftp_handle) {
unsigned long sftperr;
- CURLcode result;
if(libssh2_session_last_errno(sshc->ssh_session) ==
LIBSSH2_ERROR_EAGAIN) {
- return LIBSSH2_ERROR_EAGAIN;
+ return CURLE_AGAIN;
}
sftperr = libssh2_sftp_last_error(sshc->sftp_session);
failf(data, "Could not open remote file for reading: %s",
sftp_libssh2_strerror(sftperr));
myssh_state(data, sshc, SSH_SFTP_CLOSE);
- result = sftp_libssh2_error_to_CURLE(sftperr);
- sshc->actualcode = result ? result : CURLE_SSH;
- return ERROR_LIBBSH2;
+ return sftp_libssh2_error_to_CURLE(sftperr);
}
myssh_state(data, sshc, SSH_SFTP_DOWNLOAD_STAT);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_scp_upload_init(struct Curl_easy *data,
- struct ssh_conn *sshc,
- struct SSHPROTO *sshp)
+static CURLcode ssh_state_scp_upload_init(struct Curl_easy *data,
+ struct ssh_conn *sshc,
+ struct SSHPROTO *sshp)
{
/*
* libssh2 requires that the destination path is a full path that
if(!sshc->ssh_channel) {
int ssh_err;
char *err_msg = NULL;
-
+ CURLcode result;
if(libssh2_session_last_errno(sshc->ssh_session) ==
- LIBSSH2_ERROR_EAGAIN) {
- return LIBSSH2_ERROR_EAGAIN;
- }
+ LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
ssh_err = (int)(libssh2_session_last_error(sshc->ssh_session,
&err_msg, NULL, 0));
failf(data, "%s", err_msg);
myssh_state(data, sshc, SSH_SCP_CHANNEL_FREE);
- sshc->actualcode = libssh2_session_error_to_CURLE(ssh_err);
+ result = libssh2_session_error_to_CURLE(ssh_err);
+
/* Map generic errors to upload failed */
- if(sshc->actualcode == CURLE_SSH ||
- sshc->actualcode == CURLE_REMOTE_FILE_NOT_FOUND)
- sshc->actualcode = CURLE_UPLOAD_FAILED;
- return ERROR_LIBBSH2;
+ if(result == CURLE_SSH ||
+ result == CURLE_REMOTE_FILE_NOT_FOUND)
+ result = CURLE_UPLOAD_FAILED;
+ return result;
}
/* upload data */
myssh_state(data, sshc, SSH_STOP);
- return 0;
+ return CURLE_OK;
}
-static int ssh_state_session_disconnect(struct Curl_easy *data,
- struct ssh_conn *sshc)
+static CURLcode ssh_state_session_disconnect(struct Curl_easy *data,
+ struct ssh_conn *sshc)
{
/* during weird times when we have been prematurely aborted, the channel
is still alive when we reach this state and we MUST kill the channel
int rc = 0;
if(sshc->ssh_channel) {
rc = libssh2_channel_free(sshc->ssh_channel);
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_OK;
+
if(rc < 0) {
char *err_msg = NULL;
(void)libssh2_session_last_error(sshc->ssh_session,
if(sshc->ssh_session) {
rc = libssh2_session_disconnect(sshc->ssh_session, "Shutdown");
- if(rc == LIBSSH2_ERROR_EAGAIN) {
- return rc;
- }
+ if(rc == LIBSSH2_ERROR_EAGAIN)
+ return CURLE_AGAIN;
+
if(rc < 0) {
char *err_msg = NULL;
(void)libssh2_session_last_error(sshc->ssh_session,
Curl_safefree(sshc->homedir);
myssh_state(data, sshc, SSH_SESSION_FREE);
- return 0;
+ return CURLE_OK;
}
/*
* ssh_statemachine() runs the SSH state machine as far as it can without
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
- int rc = LIBSSH2_ERROR_NONE;
*block = 0; /* we are not blocking by default */
do {
switch(sshc->state) {
case SSH_INIT:
- rc = ssh_state_init(data, sshc);
- if(rc)
+ result = ssh_state_init(data, sshc);
+ if(result)
break;
FALLTHROUGH();
case SSH_S_STARTUP:
- rc = ssh_state_startup(data, sshc);
- if(rc)
+ result = ssh_state_startup(data, sshc);
+ if(result)
break;
FALLTHROUGH();
case SSH_HOSTKEY:
- rc = ssh_state_hostkey(data, sshc);
+ result = ssh_state_hostkey(data, sshc);
break;
case SSH_AUTHLIST:
- rc = ssh_state_authlist(data, sshc);
+ result = ssh_state_authlist(data, sshc);
break;
case SSH_AUTH_PKEY_INIT:
- rc = ssh_state_pkey_init(data, sshc);
+ result = ssh_state_pkey_init(data, sshc);
break;
case SSH_AUTH_PKEY:
- rc = ssh_state_auth_pkey(data, sshc);
+ result = ssh_state_auth_pkey(data, sshc);
break;
case SSH_AUTH_PASS_INIT:
- rc = ssh_state_auth_pass_init(data, sshc);
+ result = ssh_state_auth_pass_init(data, sshc);
break;
case SSH_AUTH_PASS:
- rc = ssh_state_auth_pass(data, sshc);
+ result = ssh_state_auth_pass(data, sshc);
break;
case SSH_AUTH_HOST_INIT:
- rc = ssh_state_auth_host_init(data, sshc);
+ result = ssh_state_auth_host_init(data, sshc);
break;
case SSH_AUTH_HOST:
break;
case SSH_AUTH_AGENT_INIT:
- rc = ssh_state_auth_agent_init(data, sshc);
+ result = ssh_state_auth_agent_init(data, sshc);
break;
case SSH_AUTH_AGENT_LIST:
- rc = ssh_state_auth_agent_list(data, sshc);
+ result = ssh_state_auth_agent_list(data, sshc);
break;
case SSH_AUTH_AGENT:
- rc = ssh_state_auth_agent(data, sshc);
+ result = ssh_state_auth_agent(data, sshc);
break;
case SSH_AUTH_KEY_INIT:
- rc = ssh_state_auth_key_init(data, sshc);
+ result = ssh_state_auth_key_init(data, sshc);
break;
case SSH_AUTH_KEY:
- rc = ssh_state_auth_key(data, sshc);
+ result = ssh_state_auth_key(data, sshc);
break;
case SSH_AUTH_DONE:
- rc = ssh_state_auth_done(data, sshc);
+ result = ssh_state_auth_done(data, sshc);
break;
case SSH_SFTP_INIT:
- rc = ssh_state_sftp_init(data, sshc);
+ result = ssh_state_sftp_init(data, sshc);
break;
case SSH_SFTP_REALPATH:
- rc = ssh_state_sftp_realpath(data, sshc, sshp);
+ result = ssh_state_sftp_realpath(data, sshc, sshp);
break;
case SSH_SFTP_QUOTE_INIT:
- rc = ssh_state_sftp_quote_init(data, sshc, sshp);
+ result = ssh_state_sftp_quote_init(data, sshc, sshp);
break;
case SSH_SFTP_POSTQUOTE_INIT:
- rc = ssh_state_sftp_postquote_init(data, sshc);
+ result = ssh_state_sftp_postquote_init(data, sshc);
break;
case SSH_SFTP_QUOTE:
- rc = ssh_state_sftp_quote(data, sshc, sshp);
+ result = ssh_state_sftp_quote(data, sshc, sshp);
break;
case SSH_SFTP_NEXT_QUOTE:
- rc = ssh_state_sftp_next_quote(data, sshc);
+ result = ssh_state_sftp_next_quote(data, sshc);
break;
case SSH_SFTP_QUOTE_STAT:
- rc = ssh_state_sftp_quote_stat(data, sshc, sshp, block);
+ result = ssh_state_sftp_quote_stat(data, sshc, sshp, block);
break;
case SSH_SFTP_QUOTE_SETSTAT:
- rc = ssh_state_sftp_quote_setstat(data, sshc, sshp);
+ result = ssh_state_sftp_quote_setstat(data, sshc, sshp);
break;
case SSH_SFTP_QUOTE_SYMLINK:
- rc = ssh_state_sftp_quote_symlink(data, sshc);
+ result = ssh_state_sftp_quote_symlink(data, sshc);
break;
case SSH_SFTP_QUOTE_MKDIR:
- rc = ssh_state_sftp_quote_mkdir(data, sshc);
+ result = ssh_state_sftp_quote_mkdir(data, sshc);
break;
case SSH_SFTP_QUOTE_RENAME:
- rc = ssh_state_sftp_quote_rename(data, sshc);
+ result = ssh_state_sftp_quote_rename(data, sshc);
break;
case SSH_SFTP_QUOTE_RMDIR:
- rc = ssh_state_sftp_quote_rmdir(data, sshc);
+ result = ssh_state_sftp_quote_rmdir(data, sshc);
break;
case SSH_SFTP_QUOTE_UNLINK:
- rc = ssh_state_sftp_quote_unlink(data, sshc);
+ result = ssh_state_sftp_quote_unlink(data, sshc);
break;
case SSH_SFTP_QUOTE_STATVFS:
- rc = ssh_state_sftp_quote_statvfs(data, sshc);
+ result = ssh_state_sftp_quote_statvfs(data, sshc);
break;
case SSH_SFTP_GETINFO:
{
LIBSSH2_SFTP_ATTRIBUTES attrs;
- rc = libssh2_sftp_stat_ex(sshc->sftp_session, sshp->path,
- curlx_uztoui(strlen(sshp->path)),
- LIBSSH2_SFTP_STAT, &attrs);
+ int rc = libssh2_sftp_stat_ex(sshc->sftp_session, sshp->path,
+ curlx_uztoui(strlen(sshp->path)),
+ LIBSSH2_SFTP_STAT, &attrs);
if(rc == LIBSSH2_ERROR_EAGAIN) {
+ result = CURLE_AGAIN;
break;
}
if(rc == 0) {
if(result) {
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = result;
}
break;
break;
case SSH_SFTP_CREATE_DIRS_MKDIR:
- rc = ssh_state_sftp_create_dirs_mkdir(data, sshc, sshp);
+ result = ssh_state_sftp_create_dirs_mkdir(data, sshc, sshp);
break;
case SSH_SFTP_READDIR_INIT:
- rc = ssh_state_sftp_readdir_init(data, sshc, sshp);
+ result = ssh_state_sftp_readdir_init(data, sshc, sshp);
break;
case SSH_SFTP_READDIR:
result = sftp_readdir(data, sshc, sshp, block);
if(result) {
- sshc->actualcode = result;
myssh_state(data, sshc, SSH_SFTP_CLOSE);
- rc = ERROR_LIBBSH2;
}
break;
case SSH_SFTP_READDIR_LINK:
- rc = ssh_state_sftp_readdir_link(data, sshc, sshp);
+ result = ssh_state_sftp_readdir_link(data, sshc, sshp);
break;
case SSH_SFTP_READDIR_BOTTOM:
curlx_dyn_len(&sshp->readdir));
if(result) {
- sshc->actualcode = result;
curlx_dyn_free(&sshp->readdir);
myssh_state(data, sshc, SSH_STOP);
}
break;
case SSH_SFTP_READDIR_DONE:
- if(libssh2_sftp_closedir(sshc->sftp_handle) ==
- LIBSSH2_ERROR_EAGAIN) {
- rc = LIBSSH2_ERROR_EAGAIN;
- break;
- }
- sshc->sftp_handle = NULL;
+ if(libssh2_sftp_closedir(sshc->sftp_handle) == LIBSSH2_ERROR_EAGAIN)
+ result = CURLE_AGAIN;
+ else {
+ sshc->sftp_handle = NULL;
- /* no data to transfer */
- Curl_xfer_setup_nop(data);
- myssh_state(data, sshc, SSH_STOP);
+ /* no data to transfer */
+ Curl_xfer_setup_nop(data);
+ myssh_state(data, sshc, SSH_STOP);
+ }
break;
case SSH_SFTP_DOWNLOAD_INIT:
- rc = ssh_state_sftp_download_init(data, sshc, sshp);
+ result = ssh_state_sftp_download_init(data, sshc, sshp);
break;
case SSH_SFTP_DOWNLOAD_STAT:
if(result) {
myssh_state(data, sshc, SSH_SFTP_CLOSE);
sshc->nextstate = SSH_NO_STATE;
- sshc->actualcode = result;
}
break;
case SSH_SFTP_CLOSE:
- rc = ssh_state_sftp_close(data, sshc, sshp);
+ result = ssh_state_sftp_close(data, sshc, sshp);
break;
case SSH_SFTP_SHUTDOWN:
- rc = ssh_state_sftp_shutdown(data, sshc);
+ result = ssh_state_sftp_shutdown(data, sshc);
break;
case SSH_SCP_TRANS_INIT:
result = Curl_getworkingpath(data, sshc->homedir, &sshp->path);
if(result) {
- sshc->actualcode = result;
myssh_state(data, sshc, SSH_STOP);
break;
}
if(data->state.upload) {
if(data->state.infilesize < 0) {
failf(data, "SCP requires a known file size for upload");
- sshc->actualcode = CURLE_UPLOAD_FAILED;
+ result = CURLE_UPLOAD_FAILED;
myssh_state(data, sshc, SSH_SCP_CHANNEL_FREE);
break;
}
break;
case SSH_SCP_UPLOAD_INIT:
- rc = ssh_state_scp_upload_init(data, sshc, sshp);
+ result = ssh_state_scp_upload_init(data, sshc, sshp);
break;
case SSH_SCP_DOWNLOAD_INIT:
- rc = ssh_state_scp_download_init(data, sshc, sshp);
+ result = ssh_state_scp_download_init(data, sshc, sshp);
break;
case SSH_SCP_DONE:
case SSH_SCP_SEND_EOF:
if(sshc->ssh_channel) {
- rc = libssh2_channel_send_eof(sshc->ssh_channel);
+ int rc = libssh2_channel_send_eof(sshc->ssh_channel);
if(rc == LIBSSH2_ERROR_EAGAIN) {
+ result = CURLE_AGAIN;
break;
}
if(rc) {
case SSH_SCP_WAIT_EOF:
if(sshc->ssh_channel) {
- rc = libssh2_channel_wait_eof(sshc->ssh_channel);
+ int rc = libssh2_channel_wait_eof(sshc->ssh_channel);
if(rc == LIBSSH2_ERROR_EAGAIN) {
+ result = CURLE_AGAIN;
break;
}
if(rc) {
case SSH_SCP_WAIT_CLOSE:
if(sshc->ssh_channel) {
- rc = libssh2_channel_wait_closed(sshc->ssh_channel);
+ int rc = libssh2_channel_wait_closed(sshc->ssh_channel);
if(rc == LIBSSH2_ERROR_EAGAIN) {
+ result = CURLE_AGAIN;
break;
}
if(rc) {
case SSH_SCP_CHANNEL_FREE:
if(sshc->ssh_channel) {
- rc = libssh2_channel_free(sshc->ssh_channel);
+ int rc = libssh2_channel_free(sshc->ssh_channel);
if(rc == LIBSSH2_ERROR_EAGAIN) {
+ result = CURLE_AGAIN;
break;
}
if(rc < 0) {
sshc->ssh_channel = NULL;
}
DEBUGF(infof(data, "SCP DONE phase complete"));
-#if 0 /* PREV */
- myssh_state(data, sshc, SSH_SESSION_DISCONNECT);
-#endif
myssh_state(data, sshc, SSH_STOP);
break;
case SSH_SESSION_DISCONNECT:
- rc = ssh_state_session_disconnect(data, sshc);
+ result = ssh_state_session_disconnect(data, sshc);
break;
case SSH_SESSION_FREE:
- rc = sshc_cleanup(sshc, data, FALSE);
- if(rc == LIBSSH2_ERROR_EAGAIN)
+ result = sshc_cleanup(sshc, data, FALSE);
+ if(result)
break;
/* the code we are about to return */
memset(sshc, 0, sizeof(struct ssh_conn));
connclose(conn, "SSH session free");
sshc->state = SSH_SESSION_FREE; /* current */
- sshc->nextstate = SSH_NO_STATE;
myssh_state(data, sshc, SSH_STOP);
break;
case SSH_QUIT:
default:
/* internal error */
- sshc->nextstate = SSH_NO_STATE;
myssh_state(data, sshc, SSH_STOP);
break;
}
- } while(!rc && (sshc->state != SSH_STOP));
+ } while(!result && (sshc->state != SSH_STOP));
- if(rc == LIBSSH2_ERROR_EAGAIN) {
+ if(result == CURLE_AGAIN) {
/* we would block, we need to wait for the socket to be ready (in the
right direction too)! */
*block = TRUE;
+ result = CURLE_OK;
}
- return sshc->actualcode;
+ return result;
}
/* called by the multi interface to figure out what socket(s) to wait for and
return CURLE_FAILED_INIT;
data->req.size = -1; /* make sure this is unknown at this point */
-
- sshc->actualcode = CURLE_OK; /* reset error code */
sshc->secondCreateDirs = 0; /* reset the create dir attempt state
variable */
return result;
}
-static int sshc_cleanup(struct ssh_conn *sshc, struct Curl_easy *data,
- bool block)
+static CURLcode sshc_cleanup(struct ssh_conn *sshc, struct Curl_easy *data,
+ bool block)
{
int rc;
if(sshc->ssh_agent) {
rc = libssh2_agent_disconnect(sshc->ssh_agent);
- if(!block && (rc == LIBSSH2_ERROR_EAGAIN)) {
- return rc;
- }
+ if(!block && (rc == LIBSSH2_ERROR_EAGAIN))
+ return CURLE_AGAIN;
+
if((rc < 0) && data) {
char *err_msg = NULL;
(void)libssh2_session_last_error(sshc->ssh_session,
if(sshc->sftp_handle) {
rc = libssh2_sftp_close(sshc->sftp_handle);
- if(!block && (rc == LIBSSH2_ERROR_EAGAIN)) {
- return rc;
- }
+ if(!block && (rc == LIBSSH2_ERROR_EAGAIN))
+ return CURLE_AGAIN;
+
if((rc < 0) && data) {
char *err_msg = NULL;
(void)libssh2_session_last_error(sshc->ssh_session, &err_msg,
if(sshc->ssh_channel) {
rc = libssh2_channel_free(sshc->ssh_channel);
- if(!block && (rc == LIBSSH2_ERROR_EAGAIN)) {
- return rc;
- }
+ if(!block && (rc == LIBSSH2_ERROR_EAGAIN))
+ return CURLE_AGAIN;
+
if((rc < 0) && data) {
char *err_msg = NULL;
(void)libssh2_session_last_error(sshc->ssh_session,
if(sshc->sftp_session) {
rc = libssh2_sftp_shutdown(sshc->sftp_session);
- if(!block && (rc == LIBSSH2_ERROR_EAGAIN)) {
- return rc;
- }
+ if(!block && (rc == LIBSSH2_ERROR_EAGAIN))
+ return CURLE_AGAIN;
+
if((rc < 0) && data)
infof(data, "Failed to stop libssh2 sftp subsystem");
sshc->sftp_session = NULL;
if(sshc->ssh_session) {
rc = libssh2_session_free(sshc->ssh_session);
- if(!block && (rc == LIBSSH2_ERROR_EAGAIN)) {
- return rc;
- }
+ if(!block && (rc == LIBSSH2_ERROR_EAGAIN))
+ return CURLE_AGAIN;
+
if((rc < 0) && data) {
char *err_msg = NULL;
(void)libssh2_session_last_error(sshc->ssh_session,
Curl_safefree(sshc->homedir);
sshc->initialised = FALSE;
}
- return 0;
+ return CURLE_OK;
}
}
if(sshc)
- sshc_cleanup(sshc, data, TRUE);
+ return sshc_cleanup(sshc, data, TRUE);
return result;
}
projects / thirdparty / curl.git / commitdiff
