Annotation of embedaddon/curl/lib/vssh/libssh2.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
! 9: *
! 10: * This software is licensed as described in the file COPYING, which
! 11: * you should have received as part of this distribution. The terms
! 12: * are also available at https://curl.haxx.se/docs/copyright.html.
! 13: *
! 14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 15: * copies of the Software, and permit persons to whom the Software is
! 16: * furnished to do so, under the terms of the COPYING file.
! 17: *
! 18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 19: * KIND, either express or implied.
! 20: *
! 21: ***************************************************************************/
! 22:
! 23: /* #define CURL_LIBSSH2_DEBUG */
! 24:
! 25: #include "curl_setup.h"
! 26:
! 27: #ifdef USE_LIBSSH2
! 28:
! 29: #include <limits.h>
! 30:
! 31: #include <libssh2.h>
! 32: #include <libssh2_sftp.h>
! 33:
! 34: #ifdef HAVE_FCNTL_H
! 35: #include <fcntl.h>
! 36: #endif
! 37:
! 38: #ifdef HAVE_NETINET_IN_H
! 39: #include <netinet/in.h>
! 40: #endif
! 41: #ifdef HAVE_ARPA_INET_H
! 42: #include <arpa/inet.h>
! 43: #endif
! 44: #ifdef HAVE_UTSNAME_H
! 45: #include <sys/utsname.h>
! 46: #endif
! 47: #ifdef HAVE_NETDB_H
! 48: #include <netdb.h>
! 49: #endif
! 50: #ifdef __VMS
! 51: #include <in.h>
! 52: #include <inet.h>
! 53: #endif
! 54:
! 55: #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
! 56: #undef in_addr_t
! 57: #define in_addr_t unsigned long
! 58: #endif
! 59:
! 60: #include <curl/curl.h>
! 61: #include "urldata.h"
! 62: #include "sendf.h"
! 63: #include "hostip.h"
! 64: #include "progress.h"
! 65: #include "transfer.h"
! 66: #include "escape.h"
! 67: #include "http.h" /* for HTTP proxy tunnel stuff */
! 68: #include "ssh.h"
! 69: #include "url.h"
! 70: #include "speedcheck.h"
! 71: #include "getinfo.h"
! 72: #include "strdup.h"
! 73: #include "strcase.h"
! 74: #include "vtls/vtls.h"
! 75: #include "connect.h"
! 76: #include "strerror.h"
! 77: #include "inet_ntop.h"
! 78: #include "parsedate.h" /* for the week day and month names */
! 79: #include "sockaddr.h" /* required for Curl_sockaddr_storage */
! 80: #include "strtoofft.h"
! 81: #include "multiif.h"
! 82: #include "select.h"
! 83: #include "warnless.h"
! 84: #include "curl_path.h"
! 85:
! 86: /* The last 3 #include files should be in this order */
! 87: #include "curl_printf.h"
! 88: #include "curl_memory.h"
! 89: #include "memdebug.h"
! 90:
! 91: #if LIBSSH2_VERSION_NUM >= 0x010206
! 92: /* libssh2_sftp_statvfs and friends were added in 1.2.6 */
! 93: #define HAS_STATVFS_SUPPORT 1
! 94: #endif
! 95:
! 96: #define sftp_libssh2_last_error(s) curlx_ultosi(libssh2_sftp_last_error(s))
! 97:
! 98: #define sftp_libssh2_realpath(s,p,t,m) \
! 99: libssh2_sftp_symlink_ex((s), (p), curlx_uztoui(strlen(p)), \
! 100: (t), (m), LIBSSH2_SFTP_REALPATH)
! 101:
! 102:
! 103: /* Local functions: */
! 104: static const char *sftp_libssh2_strerror(int err);
! 105: static LIBSSH2_ALLOC_FUNC(my_libssh2_malloc);
! 106: static LIBSSH2_REALLOC_FUNC(my_libssh2_realloc);
! 107: static LIBSSH2_FREE_FUNC(my_libssh2_free);
! 108:
! 109: static CURLcode ssh_force_knownhost_key_type(struct connectdata *conn);
! 110: static CURLcode ssh_connect(struct connectdata *conn, bool *done);
! 111: static CURLcode ssh_multi_statemach(struct connectdata *conn, bool *done);
! 112: static CURLcode ssh_do(struct connectdata *conn, bool *done);
! 113:
! 114: static CURLcode scp_done(struct connectdata *conn,
! 115: CURLcode, bool premature);
! 116: static CURLcode scp_doing(struct connectdata *conn,
! 117: bool *dophase_done);
! 118: static CURLcode scp_disconnect(struct connectdata *conn, bool dead_connection);
! 119:
! 120: static CURLcode sftp_done(struct connectdata *conn,
! 121: CURLcode, bool premature);
! 122: static CURLcode sftp_doing(struct connectdata *conn,
! 123: bool *dophase_done);
! 124: static CURLcode sftp_disconnect(struct connectdata *conn, bool dead);
! 125: static
! 126: CURLcode sftp_perform(struct connectdata *conn,
! 127: bool *connected,
! 128: bool *dophase_done);
! 129: static int ssh_getsock(struct connectdata *conn, curl_socket_t *sock);
! 130: static int ssh_perform_getsock(const struct connectdata *conn,
! 131: curl_socket_t *sock);
! 132: static CURLcode ssh_setup_connection(struct connectdata *conn);
! 133:
! 134: /*
! 135: * SCP protocol handler.
! 136: */
! 137:
! 138: const struct Curl_handler Curl_handler_scp = {
! 139: "SCP", /* scheme */
! 140: ssh_setup_connection, /* setup_connection */
! 141: ssh_do, /* do_it */
! 142: scp_done, /* done */
! 143: ZERO_NULL, /* do_more */
! 144: ssh_connect, /* connect_it */
! 145: ssh_multi_statemach, /* connecting */
! 146: scp_doing, /* doing */
! 147: ssh_getsock, /* proto_getsock */
! 148: ssh_getsock, /* doing_getsock */
! 149: ZERO_NULL, /* domore_getsock */
! 150: ssh_perform_getsock, /* perform_getsock */
! 151: scp_disconnect, /* disconnect */
! 152: ZERO_NULL, /* readwrite */
! 153: ZERO_NULL, /* connection_check */
! 154: PORT_SSH, /* defport */
! 155: CURLPROTO_SCP, /* protocol */
! 156: PROTOPT_DIRLOCK | PROTOPT_CLOSEACTION
! 157: | PROTOPT_NOURLQUERY /* flags */
! 158: };
! 159:
! 160:
! 161: /*
! 162: * SFTP protocol handler.
! 163: */
! 164:
! 165: const struct Curl_handler Curl_handler_sftp = {
! 166: "SFTP", /* scheme */
! 167: ssh_setup_connection, /* setup_connection */
! 168: ssh_do, /* do_it */
! 169: sftp_done, /* done */
! 170: ZERO_NULL, /* do_more */
! 171: ssh_connect, /* connect_it */
! 172: ssh_multi_statemach, /* connecting */
! 173: sftp_doing, /* doing */
! 174: ssh_getsock, /* proto_getsock */
! 175: ssh_getsock, /* doing_getsock */
! 176: ZERO_NULL, /* domore_getsock */
! 177: ssh_perform_getsock, /* perform_getsock */
! 178: sftp_disconnect, /* disconnect */
! 179: ZERO_NULL, /* readwrite */
! 180: ZERO_NULL, /* connection_check */
! 181: PORT_SSH, /* defport */
! 182: CURLPROTO_SFTP, /* protocol */
! 183: PROTOPT_DIRLOCK | PROTOPT_CLOSEACTION
! 184: | PROTOPT_NOURLQUERY /* flags */
! 185: };
! 186:
! 187: static void
! 188: kbd_callback(const char *name, int name_len, const char *instruction,
! 189: int instruction_len, int num_prompts,
! 190: const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
! 191: LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
! 192: void **abstract)
! 193: {
! 194: struct connectdata *conn = (struct connectdata *)*abstract;
! 195:
! 196: #ifdef CURL_LIBSSH2_DEBUG
! 197: fprintf(stderr, "name=%s\n", name);
! 198: fprintf(stderr, "name_len=%d\n", name_len);
! 199: fprintf(stderr, "instruction=%s\n", instruction);
! 200: fprintf(stderr, "instruction_len=%d\n", instruction_len);
! 201: fprintf(stderr, "num_prompts=%d\n", num_prompts);
! 202: #else
! 203: (void)name;
! 204: (void)name_len;
! 205: (void)instruction;
! 206: (void)instruction_len;
! 207: #endif /* CURL_LIBSSH2_DEBUG */
! 208: if(num_prompts == 1) {
! 209: responses[0].text = strdup(conn->passwd);
! 210: responses[0].length = curlx_uztoui(strlen(conn->passwd));
! 211: }
! 212: (void)prompts;
! 213: (void)abstract;
! 214: } /* kbd_callback */
! 215:
! 216: static CURLcode sftp_libssh2_error_to_CURLE(int err)
! 217: {
! 218: switch(err) {
! 219: case LIBSSH2_FX_OK:
! 220: return CURLE_OK;
! 221:
! 222: case LIBSSH2_FX_NO_SUCH_FILE:
! 223: case LIBSSH2_FX_NO_SUCH_PATH:
! 224: return CURLE_REMOTE_FILE_NOT_FOUND;
! 225:
! 226: case LIBSSH2_FX_PERMISSION_DENIED:
! 227: case LIBSSH2_FX_WRITE_PROTECT:
! 228: case LIBSSH2_FX_LOCK_CONFlICT:
! 229: return CURLE_REMOTE_ACCESS_DENIED;
! 230:
! 231: case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:
! 232: case LIBSSH2_FX_QUOTA_EXCEEDED:
! 233: return CURLE_REMOTE_DISK_FULL;
! 234:
! 235: case LIBSSH2_FX_FILE_ALREADY_EXISTS:
! 236: return CURLE_REMOTE_FILE_EXISTS;
! 237:
! 238: case LIBSSH2_FX_DIR_NOT_EMPTY:
! 239: return CURLE_QUOTE_ERROR;
! 240:
! 241: default:
! 242: break;
! 243: }
! 244:
! 245: return CURLE_SSH;
! 246: }
! 247:
! 248: static CURLcode libssh2_session_error_to_CURLE(int err)
! 249: {
! 250: switch(err) {
! 251: /* Ordered by order of appearance in libssh2.h */
! 252: case LIBSSH2_ERROR_NONE:
! 253: return CURLE_OK;
! 254:
! 255: /* This is the error returned by libssh2_scp_recv2
! 256: * on unknown file */
! 257: case LIBSSH2_ERROR_SCP_PROTOCOL:
! 258: return CURLE_REMOTE_FILE_NOT_FOUND;
! 259:
! 260: case LIBSSH2_ERROR_SOCKET_NONE:
! 261: return CURLE_COULDNT_CONNECT;
! 262:
! 263: case LIBSSH2_ERROR_ALLOC:
! 264: return CURLE_OUT_OF_MEMORY;
! 265:
! 266: case LIBSSH2_ERROR_SOCKET_SEND:
! 267: return CURLE_SEND_ERROR;
! 268:
! 269: case LIBSSH2_ERROR_HOSTKEY_INIT:
! 270: case LIBSSH2_ERROR_HOSTKEY_SIGN:
! 271: case LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED:
! 272: case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:
! 273: return CURLE_PEER_FAILED_VERIFICATION;
! 274:
! 275: case LIBSSH2_ERROR_PASSWORD_EXPIRED:
! 276: return CURLE_LOGIN_DENIED;
! 277:
! 278: case LIBSSH2_ERROR_SOCKET_TIMEOUT:
! 279: case LIBSSH2_ERROR_TIMEOUT:
! 280: return CURLE_OPERATION_TIMEDOUT;
! 281:
! 282: case LIBSSH2_ERROR_EAGAIN:
! 283: return CURLE_AGAIN;
! 284: }
! 285:
! 286: return CURLE_SSH;
! 287: }
! 288:
! 289: static LIBSSH2_ALLOC_FUNC(my_libssh2_malloc)
! 290: {
! 291: (void)abstract; /* arg not used */
! 292: return malloc(count);
! 293: }
! 294:
! 295: static LIBSSH2_REALLOC_FUNC(my_libssh2_realloc)
! 296: {
! 297: (void)abstract; /* arg not used */
! 298: return realloc(ptr, count);
! 299: }
! 300:
! 301: static LIBSSH2_FREE_FUNC(my_libssh2_free)
! 302: {
! 303: (void)abstract; /* arg not used */
! 304: if(ptr) /* ssh2 agent sometimes call free with null ptr */
! 305: free(ptr);
! 306: }
! 307:
! 308: /*
! 309: * SSH State machine related code
! 310: */
! 311: /* This is the ONLY way to change SSH state! */
! 312: static void state(struct connectdata *conn, sshstate nowstate)
! 313: {
! 314: struct ssh_conn *sshc = &conn->proto.sshc;
! 315: #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
! 316: /* for debug purposes */
! 317: static const char * const names[] = {
! 318: "SSH_STOP",
! 319: "SSH_INIT",
! 320: "SSH_S_STARTUP",
! 321: "SSH_HOSTKEY",
! 322: "SSH_AUTHLIST",
! 323: "SSH_AUTH_PKEY_INIT",
! 324: "SSH_AUTH_PKEY",
! 325: "SSH_AUTH_PASS_INIT",
! 326: "SSH_AUTH_PASS",
! 327: "SSH_AUTH_AGENT_INIT",
! 328: "SSH_AUTH_AGENT_LIST",
! 329: "SSH_AUTH_AGENT",
! 330: "SSH_AUTH_HOST_INIT",
! 331: "SSH_AUTH_HOST",
! 332: "SSH_AUTH_KEY_INIT",
! 333: "SSH_AUTH_KEY",
! 334: "SSH_AUTH_GSSAPI",
! 335: "SSH_AUTH_DONE",
! 336: "SSH_SFTP_INIT",
! 337: "SSH_SFTP_REALPATH",
! 338: "SSH_SFTP_QUOTE_INIT",
! 339: "SSH_SFTP_POSTQUOTE_INIT",
! 340: "SSH_SFTP_QUOTE",
! 341: "SSH_SFTP_NEXT_QUOTE",
! 342: "SSH_SFTP_QUOTE_STAT",
! 343: "SSH_SFTP_QUOTE_SETSTAT",
! 344: "SSH_SFTP_QUOTE_SYMLINK",
! 345: "SSH_SFTP_QUOTE_MKDIR",
! 346: "SSH_SFTP_QUOTE_RENAME",
! 347: "SSH_SFTP_QUOTE_RMDIR",
! 348: "SSH_SFTP_QUOTE_UNLINK",
! 349: "SSH_SFTP_QUOTE_STATVFS",
! 350: "SSH_SFTP_GETINFO",
! 351: "SSH_SFTP_FILETIME",
! 352: "SSH_SFTP_TRANS_INIT",
! 353: "SSH_SFTP_UPLOAD_INIT",
! 354: "SSH_SFTP_CREATE_DIRS_INIT",
! 355: "SSH_SFTP_CREATE_DIRS",
! 356: "SSH_SFTP_CREATE_DIRS_MKDIR",
! 357: "SSH_SFTP_READDIR_INIT",
! 358: "SSH_SFTP_READDIR",
! 359: "SSH_SFTP_READDIR_LINK",
! 360: "SSH_SFTP_READDIR_BOTTOM",
! 361: "SSH_SFTP_READDIR_DONE",
! 362: "SSH_SFTP_DOWNLOAD_INIT",
! 363: "SSH_SFTP_DOWNLOAD_STAT",
! 364: "SSH_SFTP_CLOSE",
! 365: "SSH_SFTP_SHUTDOWN",
! 366: "SSH_SCP_TRANS_INIT",
! 367: "SSH_SCP_UPLOAD_INIT",
! 368: "SSH_SCP_DOWNLOAD_INIT",
! 369: "SSH_SCP_DOWNLOAD",
! 370: "SSH_SCP_DONE",
! 371: "SSH_SCP_SEND_EOF",
! 372: "SSH_SCP_WAIT_EOF",
! 373: "SSH_SCP_WAIT_CLOSE",
! 374: "SSH_SCP_CHANNEL_FREE",
! 375: "SSH_SESSION_DISCONNECT",
! 376: "SSH_SESSION_FREE",
! 377: "QUIT"
! 378: };
! 379:
! 380: /* a precaution to make sure the lists are in sync */
! 381: DEBUGASSERT(sizeof(names)/sizeof(names[0]) == SSH_LAST);
! 382:
! 383: if(sshc->state != nowstate) {
! 384: infof(conn->data, "SFTP %p state change from %s to %s\n",
! 385: (void *)sshc, names[sshc->state], names[nowstate]);
! 386: }
! 387: #endif
! 388:
! 389: sshc->state = nowstate;
! 390: }
! 391:
! 392:
! 393: #ifdef HAVE_LIBSSH2_KNOWNHOST_API
! 394: static int sshkeycallback(struct Curl_easy *easy,
! 395: const struct curl_khkey *knownkey, /* known */
! 396: const struct curl_khkey *foundkey, /* found */
! 397: enum curl_khmatch match,
! 398: void *clientp)
! 399: {
! 400: (void)easy;
! 401: (void)knownkey;
! 402: (void)foundkey;
! 403: (void)clientp;
! 404:
! 405: /* we only allow perfect matches, and we reject everything else */
! 406: return (match != CURLKHMATCH_OK)?CURLKHSTAT_REJECT:CURLKHSTAT_FINE;
! 407: }
! 408: #endif
! 409:
! 410: /*
! 411: * Earlier libssh2 versions didn't have the ability to seek to 64bit positions
! 412: * with 32bit size_t.
! 413: */
! 414: #ifdef HAVE_LIBSSH2_SFTP_SEEK64
! 415: #define SFTP_SEEK(x,y) libssh2_sftp_seek64(x, (libssh2_uint64_t)y)
! 416: #else
! 417: #define SFTP_SEEK(x,y) libssh2_sftp_seek(x, (size_t)y)
! 418: #endif
! 419:
! 420: /*
! 421: * Earlier libssh2 versions didn't do SCP properly beyond 32bit sizes on 32bit
! 422: * architectures so we check of the necessary function is present.
! 423: */
! 424: #ifndef HAVE_LIBSSH2_SCP_SEND64
! 425: #define SCP_SEND(a,b,c,d) libssh2_scp_send_ex(a, b, (int)(c), (size_t)d, 0, 0)
! 426: #else
! 427: #define SCP_SEND(a,b,c,d) libssh2_scp_send64(a, b, (int)(c), \
! 428: (libssh2_uint64_t)d, 0, 0)
! 429: #endif
! 430:
! 431: /*
! 432: * libssh2 1.2.8 fixed the problem with 32bit ints used for sockets on win64.
! 433: */
! 434: #ifdef HAVE_LIBSSH2_SESSION_HANDSHAKE
! 435: #define libssh2_session_startup(x,y) libssh2_session_handshake(x,y)
! 436: #endif
! 437:
! 438: static CURLcode ssh_knownhost(struct connectdata *conn)
! 439: {
! 440: CURLcode result = CURLE_OK;
! 441:
! 442: #ifdef HAVE_LIBSSH2_KNOWNHOST_API
! 443: struct Curl_easy *data = conn->data;
! 444:
! 445: if(data->set.str[STRING_SSH_KNOWNHOSTS]) {
! 446: /* we're asked to verify the host against a file */
! 447: struct ssh_conn *sshc = &conn->proto.sshc;
! 448: int rc;
! 449: int keytype;
! 450: size_t keylen;
! 451: const char *remotekey = libssh2_session_hostkey(sshc->ssh_session,
! 452: &keylen, &keytype);
! 453: int keycheck = LIBSSH2_KNOWNHOST_CHECK_FAILURE;
! 454: int keybit = 0;
! 455:
! 456: if(remotekey) {
! 457: /*
! 458: * A subject to figure out is what host name we need to pass in here.
! 459: * What host name does OpenSSH store in its file if an IDN name is
! 460: * used?
! 461: */
! 462: struct libssh2_knownhost *host;
! 463: enum curl_khmatch keymatch;
! 464: curl_sshkeycallback func =
! 465: data->set.ssh_keyfunc?data->set.ssh_keyfunc:sshkeycallback;
! 466: struct curl_khkey knownkey;
! 467: struct curl_khkey *knownkeyp = NULL;
! 468: struct curl_khkey foundkey;
! 469:
! 470: switch(keytype) {
! 471: case LIBSSH2_HOSTKEY_TYPE_RSA:
! 472: keybit = LIBSSH2_KNOWNHOST_KEY_SSHRSA;
! 473: break;
! 474: case LIBSSH2_HOSTKEY_TYPE_DSS:
! 475: keybit = LIBSSH2_KNOWNHOST_KEY_SSHDSS;
! 476: break;
! 477: #ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256
! 478: case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:
! 479: keybit = LIBSSH2_KNOWNHOST_KEY_ECDSA_256;
! 480: break;
! 481: #endif
! 482: #ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_384
! 483: case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:
! 484: keybit = LIBSSH2_KNOWNHOST_KEY_ECDSA_384;
! 485: break;
! 486: #endif
! 487: #ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_521
! 488: case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:
! 489: keybit = LIBSSH2_KNOWNHOST_KEY_ECDSA_521;
! 490: break;
! 491: #endif
! 492: #ifdef LIBSSH2_HOSTKEY_TYPE_ED25519
! 493: case LIBSSH2_HOSTKEY_TYPE_ED25519:
! 494: keybit = LIBSSH2_KNOWNHOST_KEY_ED25519;
! 495: break;
! 496: #endif
! 497: default:
! 498: infof(data, "unsupported key type, can't check knownhosts!\n");
! 499: keybit = 0;
! 500: break;
! 501: }
! 502: if(!keybit)
! 503: /* no check means failure! */
! 504: rc = CURLKHSTAT_REJECT;
! 505: else {
! 506: #ifdef HAVE_LIBSSH2_KNOWNHOST_CHECKP
! 507: keycheck = libssh2_knownhost_checkp(sshc->kh,
! 508: conn->host.name,
! 509: (conn->remote_port != PORT_SSH)?
! 510: conn->remote_port:-1,
! 511: remotekey, keylen,
! 512: LIBSSH2_KNOWNHOST_TYPE_PLAIN|
! 513: LIBSSH2_KNOWNHOST_KEYENC_RAW|
! 514: keybit,
! 515: &host);
! 516: #else
! 517: keycheck = libssh2_knownhost_check(sshc->kh,
! 518: conn->host.name,
! 519: remotekey, keylen,
! 520: LIBSSH2_KNOWNHOST_TYPE_PLAIN|
! 521: LIBSSH2_KNOWNHOST_KEYENC_RAW|
! 522: keybit,
! 523: &host);
! 524: #endif
! 525:
! 526: infof(data, "SSH host check: %d, key: %s\n", keycheck,
! 527: (keycheck <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH)?
! 528: host->key:"<none>");
! 529:
! 530: /* setup 'knownkey' */
! 531: if(keycheck <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH) {
! 532: knownkey.key = host->key;
! 533: knownkey.len = 0;
! 534: knownkey.keytype = (keytype == LIBSSH2_HOSTKEY_TYPE_RSA)?
! 535: CURLKHTYPE_RSA : CURLKHTYPE_DSS;
! 536: knownkeyp = &knownkey;
! 537: }
! 538:
! 539: /* setup 'foundkey' */
! 540: foundkey.key = remotekey;
! 541: foundkey.len = keylen;
! 542: foundkey.keytype = (keytype == LIBSSH2_HOSTKEY_TYPE_RSA)?
! 543: CURLKHTYPE_RSA : CURLKHTYPE_DSS;
! 544:
! 545: /*
! 546: * if any of the LIBSSH2_KNOWNHOST_CHECK_* defines and the
! 547: * curl_khmatch enum are ever modified, we need to introduce a
! 548: * translation table here!
! 549: */
! 550: keymatch = (enum curl_khmatch)keycheck;
! 551:
! 552: /* Ask the callback how to behave */
! 553: Curl_set_in_callback(data, true);
! 554: rc = func(data, knownkeyp, /* from the knownhosts file */
! 555: &foundkey, /* from the remote host */
! 556: keymatch, data->set.ssh_keyfunc_userp);
! 557: Curl_set_in_callback(data, false);
! 558: }
! 559: }
! 560: else
! 561: /* no remotekey means failure! */
! 562: rc = CURLKHSTAT_REJECT;
! 563:
! 564: switch(rc) {
! 565: default: /* unknown return codes will equal reject */
! 566: /* FALLTHROUGH */
! 567: case CURLKHSTAT_REJECT:
! 568: state(conn, SSH_SESSION_FREE);
! 569: /* FALLTHROUGH */
! 570: case CURLKHSTAT_DEFER:
! 571: /* DEFER means bail out but keep the SSH_HOSTKEY state */
! 572: result = sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
! 573: break;
! 574: case CURLKHSTAT_FINE:
! 575: case CURLKHSTAT_FINE_ADD_TO_FILE:
! 576: /* proceed */
! 577: if(keycheck != LIBSSH2_KNOWNHOST_CHECK_MATCH) {
! 578: /* the found host+key didn't match but has been told to be fine
! 579: anyway so we add it in memory */
! 580: int addrc = libssh2_knownhost_add(sshc->kh,
! 581: conn->host.name, NULL,
! 582: remotekey, keylen,
! 583: LIBSSH2_KNOWNHOST_TYPE_PLAIN|
! 584: LIBSSH2_KNOWNHOST_KEYENC_RAW|
! 585: keybit, NULL);
! 586: if(addrc)
! 587: infof(data, "Warning adding the known host %s failed!\n",
! 588: conn->host.name);
! 589: else if(rc == CURLKHSTAT_FINE_ADD_TO_FILE) {
! 590: /* now we write the entire in-memory list of known hosts to the
! 591: known_hosts file */
! 592: int wrc =
! 593: libssh2_knownhost_writefile(sshc->kh,
! 594: data->set.str[STRING_SSH_KNOWNHOSTS],
! 595: LIBSSH2_KNOWNHOST_FILE_OPENSSH);
! 596: if(wrc) {
! 597: infof(data, "Warning, writing %s failed!\n",
! 598: data->set.str[STRING_SSH_KNOWNHOSTS]);
! 599: }
! 600: }
! 601: }
! 602: break;
! 603: }
! 604: }
! 605: #else /* HAVE_LIBSSH2_KNOWNHOST_API */
! 606: (void)conn;
! 607: #endif
! 608: return result;
! 609: }
! 610:
! 611: static CURLcode ssh_check_fingerprint(struct connectdata *conn)
! 612: {
! 613: struct ssh_conn *sshc = &conn->proto.sshc;
! 614: struct Curl_easy *data = conn->data;
! 615: const char *pubkey_md5 = data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5];
! 616: char md5buffer[33];
! 617:
! 618: const char *fingerprint = libssh2_hostkey_hash(sshc->ssh_session,
! 619: LIBSSH2_HOSTKEY_HASH_MD5);
! 620:
! 621: if(fingerprint) {
! 622: /* The fingerprint points to static storage (!), don't free() it. */
! 623: int i;
! 624: for(i = 0; i < 16; i++)
! 625: msnprintf(&md5buffer[i*2], 3, "%02x", (unsigned char) fingerprint[i]);
! 626: infof(data, "SSH MD5 fingerprint: %s\n", md5buffer);
! 627: }
! 628:
! 629: /* Before we authenticate we check the hostkey's MD5 fingerprint
! 630: * against a known fingerprint, if available.
! 631: */
! 632: if(pubkey_md5 && strlen(pubkey_md5) == 32) {
! 633: if(!fingerprint || !strcasecompare(md5buffer, pubkey_md5)) {
! 634: if(fingerprint)
! 635: failf(data,
! 636: "Denied establishing ssh session: mismatch md5 fingerprint. "
! 637: "Remote %s is not equal to %s", md5buffer, pubkey_md5);
! 638: else
! 639: failf(data,
! 640: "Denied establishing ssh session: md5 fingerprint not available");
! 641: state(conn, SSH_SESSION_FREE);
! 642: sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
! 643: return sshc->actualcode;
! 644: }
! 645: infof(data, "MD5 checksum match!\n");
! 646: /* as we already matched, we skip the check for known hosts */
! 647: return CURLE_OK;
! 648: }
! 649: return ssh_knownhost(conn);
! 650: }
! 651:
! 652: /*
! 653: * ssh_force_knownhost_key_type() will check the known hosts file and try to
! 654: * force a specific public key type from the server if an entry is found.
! 655: */
! 656: static CURLcode ssh_force_knownhost_key_type(struct connectdata *conn)
! 657: {
! 658: CURLcode result = CURLE_OK;
! 659:
! 660: #ifdef HAVE_LIBSSH2_KNOWNHOST_API
! 661:
! 662: #ifdef LIBSSH2_KNOWNHOST_KEY_ED25519
! 663: static const char * const hostkey_method_ssh_ed25519
! 664: = "ssh-ed25519";
! 665: #endif
! 666: #ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_521
! 667: static const char * const hostkey_method_ssh_ecdsa_521
! 668: = "ecdsa-sha2-nistp521";
! 669: #endif
! 670: #ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_384
! 671: static const char * const hostkey_method_ssh_ecdsa_384
! 672: = "ecdsa-sha2-nistp384";
! 673: #endif
! 674: #ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_256
! 675: static const char * const hostkey_method_ssh_ecdsa_256
! 676: = "ecdsa-sha2-nistp256";
! 677: #endif
! 678: static const char * const hostkey_method_ssh_rsa
! 679: = "ssh-rsa";
! 680: static const char * const hostkey_method_ssh_dss
! 681: = "ssh-dss";
! 682:
! 683: const char *hostkey_method = NULL;
! 684: struct ssh_conn *sshc = &conn->proto.sshc;
! 685: struct Curl_easy *data = conn->data;
! 686: struct libssh2_knownhost* store = NULL;
! 687: const char *kh_name_end = NULL;
! 688: size_t kh_name_size = 0;
! 689: int port = 0;
! 690: bool found = false;
! 691:
! 692: if(sshc->kh && !data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5]) {
! 693: /* lets try to find our host in the known hosts file */
! 694: while(!libssh2_knownhost_get(sshc->kh, &store, store)) {
! 695: /* For non-standard ports, the name will be enclosed in */
! 696: /* square brackets, followed by a colon and the port */
! 697: if(store) {
! 698: if(store->name) {
! 699: if(store->name[0] == '[') {
! 700: kh_name_end = strstr(store->name, "]:");
! 701: if(!kh_name_end) {
! 702: infof(data, "Invalid host pattern %s in %s\n",
! 703: store->name, data->set.str[STRING_SSH_KNOWNHOSTS]);
! 704: continue;
! 705: }
! 706: port = atoi(kh_name_end + 2);
! 707: if(kh_name_end && (port == conn->remote_port)) {
! 708: kh_name_size = strlen(store->name) - 1 - strlen(kh_name_end);
! 709: if(strncmp(store->name + 1,
! 710: conn->host.name, kh_name_size) == 0) {
! 711: found = true;
! 712: break;
! 713: }
! 714: }
! 715: }
! 716: else if(strcmp(store->name, conn->host.name) == 0) {
! 717: found = true;
! 718: break;
! 719: }
! 720: }
! 721: else {
! 722: found = true;
! 723: break;
! 724: }
! 725: }
! 726: }
! 727:
! 728: if(found) {
! 729: infof(data, "Found host %s in %s\n",
! 730: conn->host.name, data->set.str[STRING_SSH_KNOWNHOSTS]);
! 731:
! 732: switch(store->typemask & LIBSSH2_KNOWNHOST_KEY_MASK) {
! 733: #ifdef LIBSSH2_KNOWNHOST_KEY_ED25519
! 734: case LIBSSH2_KNOWNHOST_KEY_ED25519:
! 735: hostkey_method = hostkey_method_ssh_ed25519;
! 736: break;
! 737: #endif
! 738: #ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_521
! 739: case LIBSSH2_KNOWNHOST_KEY_ECDSA_521:
! 740: hostkey_method = hostkey_method_ssh_ecdsa_521;
! 741: break;
! 742: #endif
! 743: #ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_384
! 744: case LIBSSH2_KNOWNHOST_KEY_ECDSA_384:
! 745: hostkey_method = hostkey_method_ssh_ecdsa_384;
! 746: break;
! 747: #endif
! 748: #ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_256
! 749: case LIBSSH2_KNOWNHOST_KEY_ECDSA_256:
! 750: hostkey_method = hostkey_method_ssh_ecdsa_256;
! 751: break;
! 752: #endif
! 753: case LIBSSH2_KNOWNHOST_KEY_SSHRSA:
! 754: hostkey_method = hostkey_method_ssh_rsa;
! 755: break;
! 756: case LIBSSH2_KNOWNHOST_KEY_SSHDSS:
! 757: hostkey_method = hostkey_method_ssh_dss;
! 758: break;
! 759: case LIBSSH2_KNOWNHOST_KEY_RSA1:
! 760: failf(data, "Found host key type RSA1 which is not supported\n");
! 761: return CURLE_SSH;
! 762: default:
! 763: failf(data, "Unknown host key type: %i\n",
! 764: (store->typemask & LIBSSH2_KNOWNHOST_KEY_MASK));
! 765: return CURLE_SSH;
! 766: }
! 767:
! 768: infof(data, "Set \"%s\" as SSH hostkey type\n", hostkey_method);
! 769: result = libssh2_session_error_to_CURLE(
! 770: libssh2_session_method_pref(
! 771: sshc->ssh_session, LIBSSH2_METHOD_HOSTKEY, hostkey_method));
! 772: }
! 773: else {
! 774: infof(data, "Did not find host %s in %s\n",
! 775: conn->host.name, data->set.str[STRING_SSH_KNOWNHOSTS]);
! 776: }
! 777: }
! 778:
! 779: #endif /* HAVE_LIBSSH2_KNOWNHOST_API */
! 780:
! 781: return result;
! 782: }
! 783:
! 784: /*
! 785: * ssh_statemach_act() runs the SSH state machine as far as it can without
! 786: * blocking and without reaching the end. The data the pointer 'block' points
! 787: * to will be set to TRUE if the libssh2 function returns LIBSSH2_ERROR_EAGAIN
! 788: * meaning it wants to be called again when the socket is ready
! 789: */
! 790:
! 791: static CURLcode ssh_statemach_act(struct connectdata *conn, bool *block)
! 792: {
! 793: CURLcode result = CURLE_OK;
! 794: struct Curl_easy *data = conn->data;
! 795: struct SSHPROTO *sftp_scp = data->req.protop;
! 796: struct ssh_conn *sshc = &conn->proto.sshc;
! 797: curl_socket_t sock = conn->sock[FIRSTSOCKET];
! 798: char *new_readdir_line;
! 799: int rc = LIBSSH2_ERROR_NONE;
! 800: int err;
! 801: int seekerr = CURL_SEEKFUNC_OK;
! 802: *block = 0; /* we're not blocking by default */
! 803:
! 804: do {
! 805:
! 806: switch(sshc->state) {
! 807: case SSH_INIT:
! 808: sshc->secondCreateDirs = 0;
! 809: sshc->nextstate = SSH_NO_STATE;
! 810: sshc->actualcode = CURLE_OK;
! 811:
! 812: /* Set libssh2 to non-blocking, since everything internally is
! 813: non-blocking */
! 814: libssh2_session_set_blocking(sshc->ssh_session, 0);
! 815:
! 816: result = ssh_force_knownhost_key_type(conn);
! 817: if(result) {
! 818: state(conn, SSH_SESSION_FREE);
! 819: break;
! 820: }
! 821:
! 822: state(conn, SSH_S_STARTUP);
! 823: /* FALLTHROUGH */
! 824:
! 825: case SSH_S_STARTUP:
! 826: rc = libssh2_session_startup(sshc->ssh_session, (int)sock);
! 827: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 828: break;
! 829: }
! 830: if(rc) {
! 831: char *err_msg = NULL;
! 832: (void)libssh2_session_last_error(sshc->ssh_session, &err_msg, NULL, 0);
! 833: failf(data, "Failure establishing ssh session: %d, %s", rc, err_msg);
! 834:
! 835: state(conn, SSH_SESSION_FREE);
! 836: sshc->actualcode = CURLE_FAILED_INIT;
! 837: break;
! 838: }
! 839:
! 840: state(conn, SSH_HOSTKEY);
! 841:
! 842: /* FALLTHROUGH */
! 843: case SSH_HOSTKEY:
! 844: /*
! 845: * Before we authenticate we should check the hostkey's fingerprint
! 846: * against our known hosts. How that is handled (reading from file,
! 847: * whatever) is up to us.
! 848: */
! 849: result = ssh_check_fingerprint(conn);
! 850: if(!result)
! 851: state(conn, SSH_AUTHLIST);
! 852: /* ssh_check_fingerprint sets state appropriately on error */
! 853: break;
! 854:
! 855: case SSH_AUTHLIST:
! 856: /*
! 857: * Figure out authentication methods
! 858: * NB: As soon as we have provided a username to an openssh server we
! 859: * must never change it later. Thus, always specify the correct username
! 860: * here, even though the libssh2 docs kind of indicate that it should be
! 861: * possible to get a 'generic' list (not user-specific) of authentication
! 862: * methods, presumably with a blank username. That won't work in my
! 863: * experience.
! 864: * So always specify it here.
! 865: */
! 866: sshc->authlist = libssh2_userauth_list(sshc->ssh_session,
! 867: conn->user,
! 868: curlx_uztoui(strlen(conn->user)));
! 869:
! 870: if(!sshc->authlist) {
! 871: if(libssh2_userauth_authenticated(sshc->ssh_session)) {
! 872: sshc->authed = TRUE;
! 873: infof(data, "SSH user accepted with no authentication\n");
! 874: state(conn, SSH_AUTH_DONE);
! 875: break;
! 876: }
! 877: err = libssh2_session_last_errno(sshc->ssh_session);
! 878: if(err == LIBSSH2_ERROR_EAGAIN)
! 879: rc = LIBSSH2_ERROR_EAGAIN;
! 880: else {
! 881: state(conn, SSH_SESSION_FREE);
! 882: sshc->actualcode = libssh2_session_error_to_CURLE(err);
! 883: }
! 884: break;
! 885: }
! 886: infof(data, "SSH authentication methods available: %s\n",
! 887: sshc->authlist);
! 888:
! 889: state(conn, SSH_AUTH_PKEY_INIT);
! 890: break;
! 891:
! 892: case SSH_AUTH_PKEY_INIT:
! 893: /*
! 894: * Check the supported auth types in the order I feel is most secure
! 895: * with the requested type of authentication
! 896: */
! 897: sshc->authed = FALSE;
! 898:
! 899: if((data->set.ssh_auth_types & CURLSSH_AUTH_PUBLICKEY) &&
! 900: (strstr(sshc->authlist, "publickey") != NULL)) {
! 901: bool out_of_memory = FALSE;
! 902:
! 903: sshc->rsa_pub = sshc->rsa = NULL;
! 904:
! 905: if(data->set.str[STRING_SSH_PRIVATE_KEY])
! 906: sshc->rsa = strdup(data->set.str[STRING_SSH_PRIVATE_KEY]);
! 907: else {
! 908: /* To ponder about: should really the lib be messing about with the
! 909: HOME environment variable etc? */
! 910: char *home = curl_getenv("HOME");
! 911:
! 912: /* If no private key file is specified, try some common paths. */
! 913: if(home) {
! 914: /* Try ~/.ssh first. */
! 915: sshc->rsa = aprintf("%s/.ssh/id_rsa", home);
! 916: if(!sshc->rsa)
! 917: out_of_memory = TRUE;
! 918: else if(access(sshc->rsa, R_OK) != 0) {
! 919: Curl_safefree(sshc->rsa);
! 920: sshc->rsa = aprintf("%s/.ssh/id_dsa", home);
! 921: if(!sshc->rsa)
! 922: out_of_memory = TRUE;
! 923: else if(access(sshc->rsa, R_OK) != 0) {
! 924: Curl_safefree(sshc->rsa);
! 925: }
! 926: }
! 927: free(home);
! 928: }
! 929: if(!out_of_memory && !sshc->rsa) {
! 930: /* Nothing found; try the current dir. */
! 931: sshc->rsa = strdup("id_rsa");
! 932: if(sshc->rsa && access(sshc->rsa, R_OK) != 0) {
! 933: Curl_safefree(sshc->rsa);
! 934: sshc->rsa = strdup("id_dsa");
! 935: if(sshc->rsa && access(sshc->rsa, R_OK) != 0) {
! 936: Curl_safefree(sshc->rsa);
! 937: /* Out of guesses. Set to the empty string to avoid
! 938: * surprising info messages. */
! 939: sshc->rsa = strdup("");
! 940: }
! 941: }
! 942: }
! 943: }
! 944:
! 945: /*
! 946: * Unless the user explicitly specifies a public key file, let
! 947: * libssh2 extract the public key from the private key file.
! 948: * This is done by simply passing sshc->rsa_pub = NULL.
! 949: */
! 950: if(data->set.str[STRING_SSH_PUBLIC_KEY]
! 951: /* treat empty string the same way as NULL */
! 952: && data->set.str[STRING_SSH_PUBLIC_KEY][0]) {
! 953: sshc->rsa_pub = strdup(data->set.str[STRING_SSH_PUBLIC_KEY]);
! 954: if(!sshc->rsa_pub)
! 955: out_of_memory = TRUE;
! 956: }
! 957:
! 958: if(out_of_memory || sshc->rsa == NULL) {
! 959: Curl_safefree(sshc->rsa);
! 960: Curl_safefree(sshc->rsa_pub);
! 961: state(conn, SSH_SESSION_FREE);
! 962: sshc->actualcode = CURLE_OUT_OF_MEMORY;
! 963: break;
! 964: }
! 965:
! 966: sshc->passphrase = data->set.ssl.key_passwd;
! 967: if(!sshc->passphrase)
! 968: sshc->passphrase = "";
! 969:
! 970: if(sshc->rsa_pub)
! 971: infof(data, "Using SSH public key file '%s'\n", sshc->rsa_pub);
! 972: infof(data, "Using SSH private key file '%s'\n", sshc->rsa);
! 973:
! 974: state(conn, SSH_AUTH_PKEY);
! 975: }
! 976: else {
! 977: state(conn, SSH_AUTH_PASS_INIT);
! 978: }
! 979: break;
! 980:
! 981: case SSH_AUTH_PKEY:
! 982: /* The function below checks if the files exists, no need to stat() here.
! 983: */
! 984: rc = libssh2_userauth_publickey_fromfile_ex(sshc->ssh_session,
! 985: conn->user,
! 986: curlx_uztoui(
! 987: strlen(conn->user)),
! 988: sshc->rsa_pub,
! 989: sshc->rsa, sshc->passphrase);
! 990: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 991: break;
! 992: }
! 993:
! 994: Curl_safefree(sshc->rsa_pub);
! 995: Curl_safefree(sshc->rsa);
! 996:
! 997: if(rc == 0) {
! 998: sshc->authed = TRUE;
! 999: infof(data, "Initialized SSH public key authentication\n");
! 1000: state(conn, SSH_AUTH_DONE);
! 1001: }
! 1002: else {
! 1003: char *err_msg = NULL;
! 1004: (void)libssh2_session_last_error(sshc->ssh_session,
! 1005: &err_msg, NULL, 0);
! 1006: infof(data, "SSH public key authentication failed: %s\n", err_msg);
! 1007: state(conn, SSH_AUTH_PASS_INIT);
! 1008: rc = 0; /* clear rc and continue */
! 1009: }
! 1010: break;
! 1011:
! 1012: case SSH_AUTH_PASS_INIT:
! 1013: if((data->set.ssh_auth_types & CURLSSH_AUTH_PASSWORD) &&
! 1014: (strstr(sshc->authlist, "password") != NULL)) {
! 1015: state(conn, SSH_AUTH_PASS);
! 1016: }
! 1017: else {
! 1018: state(conn, SSH_AUTH_HOST_INIT);
! 1019: rc = 0; /* clear rc and continue */
! 1020: }
! 1021: break;
! 1022:
! 1023: case SSH_AUTH_PASS:
! 1024: rc = libssh2_userauth_password_ex(sshc->ssh_session, conn->user,
! 1025: curlx_uztoui(strlen(conn->user)),
! 1026: conn->passwd,
! 1027: curlx_uztoui(strlen(conn->passwd)),
! 1028: NULL);
! 1029: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1030: break;
! 1031: }
! 1032: if(rc == 0) {
! 1033: sshc->authed = TRUE;
! 1034: infof(data, "Initialized password authentication\n");
! 1035: state(conn, SSH_AUTH_DONE);
! 1036: }
! 1037: else {
! 1038: state(conn, SSH_AUTH_HOST_INIT);
! 1039: rc = 0; /* clear rc and continue */
! 1040: }
! 1041: break;
! 1042:
! 1043: case SSH_AUTH_HOST_INIT:
! 1044: if((data->set.ssh_auth_types & CURLSSH_AUTH_HOST) &&
! 1045: (strstr(sshc->authlist, "hostbased") != NULL)) {
! 1046: state(conn, SSH_AUTH_HOST);
! 1047: }
! 1048: else {
! 1049: state(conn, SSH_AUTH_AGENT_INIT);
! 1050: }
! 1051: break;
! 1052:
! 1053: case SSH_AUTH_HOST:
! 1054: state(conn, SSH_AUTH_AGENT_INIT);
! 1055: break;
! 1056:
! 1057: case SSH_AUTH_AGENT_INIT:
! 1058: #ifdef HAVE_LIBSSH2_AGENT_API
! 1059: if((data->set.ssh_auth_types & CURLSSH_AUTH_AGENT)
! 1060: && (strstr(sshc->authlist, "publickey") != NULL)) {
! 1061:
! 1062: /* Connect to the ssh-agent */
! 1063: /* The agent could be shared by a curl thread i believe
! 1064: but nothing obvious as keys can be added/removed at any time */
! 1065: if(!sshc->ssh_agent) {
! 1066: sshc->ssh_agent = libssh2_agent_init(sshc->ssh_session);
! 1067: if(!sshc->ssh_agent) {
! 1068: infof(data, "Could not create agent object\n");
! 1069:
! 1070: state(conn, SSH_AUTH_KEY_INIT);
! 1071: break;
! 1072: }
! 1073: }
! 1074:
! 1075: rc = libssh2_agent_connect(sshc->ssh_agent);
! 1076: if(rc == LIBSSH2_ERROR_EAGAIN)
! 1077: break;
! 1078: if(rc < 0) {
! 1079: infof(data, "Failure connecting to agent\n");
! 1080: state(conn, SSH_AUTH_KEY_INIT);
! 1081: rc = 0; /* clear rc and continue */
! 1082: }
! 1083: else {
! 1084: state(conn, SSH_AUTH_AGENT_LIST);
! 1085: }
! 1086: }
! 1087: else
! 1088: #endif /* HAVE_LIBSSH2_AGENT_API */
! 1089: state(conn, SSH_AUTH_KEY_INIT);
! 1090: break;
! 1091:
! 1092: case SSH_AUTH_AGENT_LIST:
! 1093: #ifdef HAVE_LIBSSH2_AGENT_API
! 1094: rc = libssh2_agent_list_identities(sshc->ssh_agent);
! 1095:
! 1096: if(rc == LIBSSH2_ERROR_EAGAIN)
! 1097: break;
! 1098: if(rc < 0) {
! 1099: infof(data, "Failure requesting identities to agent\n");
! 1100: state(conn, SSH_AUTH_KEY_INIT);
! 1101: rc = 0; /* clear rc and continue */
! 1102: }
! 1103: else {
! 1104: state(conn, SSH_AUTH_AGENT);
! 1105: sshc->sshagent_prev_identity = NULL;
! 1106: }
! 1107: #endif
! 1108: break;
! 1109:
! 1110: case SSH_AUTH_AGENT:
! 1111: #ifdef HAVE_LIBSSH2_AGENT_API
! 1112: /* as prev_identity evolves only after an identity user auth finished we
! 1113: can safely request it again as long as EAGAIN is returned here or by
! 1114: libssh2_agent_userauth */
! 1115: rc = libssh2_agent_get_identity(sshc->ssh_agent,
! 1116: &sshc->sshagent_identity,
! 1117: sshc->sshagent_prev_identity);
! 1118: if(rc == LIBSSH2_ERROR_EAGAIN)
! 1119: break;
! 1120:
! 1121: if(rc == 0) {
! 1122: rc = libssh2_agent_userauth(sshc->ssh_agent, conn->user,
! 1123: sshc->sshagent_identity);
! 1124:
! 1125: if(rc < 0) {
! 1126: if(rc != LIBSSH2_ERROR_EAGAIN) {
! 1127: /* tried and failed? go to next identity */
! 1128: sshc->sshagent_prev_identity = sshc->sshagent_identity;
! 1129: }
! 1130: break;
! 1131: }
! 1132: }
! 1133:
! 1134: if(rc < 0)
! 1135: infof(data, "Failure requesting identities to agent\n");
! 1136: else if(rc == 1)
! 1137: infof(data, "No identity would match\n");
! 1138:
! 1139: if(rc == LIBSSH2_ERROR_NONE) {
! 1140: sshc->authed = TRUE;
! 1141: infof(data, "Agent based authentication successful\n");
! 1142: state(conn, SSH_AUTH_DONE);
! 1143: }
! 1144: else {
! 1145: state(conn, SSH_AUTH_KEY_INIT);
! 1146: rc = 0; /* clear rc and continue */
! 1147: }
! 1148: #endif
! 1149: break;
! 1150:
! 1151: case SSH_AUTH_KEY_INIT:
! 1152: if((data->set.ssh_auth_types & CURLSSH_AUTH_KEYBOARD)
! 1153: && (strstr(sshc->authlist, "keyboard-interactive") != NULL)) {
! 1154: state(conn, SSH_AUTH_KEY);
! 1155: }
! 1156: else {
! 1157: state(conn, SSH_AUTH_DONE);
! 1158: }
! 1159: break;
! 1160:
! 1161: case SSH_AUTH_KEY:
! 1162: /* Authentication failed. Continue with keyboard-interactive now. */
! 1163: rc = libssh2_userauth_keyboard_interactive_ex(sshc->ssh_session,
! 1164: conn->user,
! 1165: curlx_uztoui(
! 1166: strlen(conn->user)),
! 1167: &kbd_callback);
! 1168: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1169: break;
! 1170: }
! 1171: if(rc == 0) {
! 1172: sshc->authed = TRUE;
! 1173: infof(data, "Initialized keyboard interactive authentication\n");
! 1174: }
! 1175: state(conn, SSH_AUTH_DONE);
! 1176: break;
! 1177:
! 1178: case SSH_AUTH_DONE:
! 1179: if(!sshc->authed) {
! 1180: failf(data, "Authentication failure");
! 1181: state(conn, SSH_SESSION_FREE);
! 1182: sshc->actualcode = CURLE_LOGIN_DENIED;
! 1183: break;
! 1184: }
! 1185:
! 1186: /*
! 1187: * At this point we have an authenticated ssh session.
! 1188: */
! 1189: infof(data, "Authentication complete\n");
! 1190:
! 1191: Curl_pgrsTime(conn->data, TIMER_APPCONNECT); /* SSH is connected */
! 1192:
! 1193: conn->sockfd = sock;
! 1194: conn->writesockfd = CURL_SOCKET_BAD;
! 1195:
! 1196: if(conn->handler->protocol == CURLPROTO_SFTP) {
! 1197: state(conn, SSH_SFTP_INIT);
! 1198: break;
! 1199: }
! 1200: infof(data, "SSH CONNECT phase done\n");
! 1201: state(conn, SSH_STOP);
! 1202: break;
! 1203:
! 1204: case SSH_SFTP_INIT:
! 1205: /*
! 1206: * Start the libssh2 sftp session
! 1207: */
! 1208: sshc->sftp_session = libssh2_sftp_init(sshc->ssh_session);
! 1209: if(!sshc->sftp_session) {
! 1210: char *err_msg = NULL;
! 1211: if(libssh2_session_last_errno(sshc->ssh_session) ==
! 1212: LIBSSH2_ERROR_EAGAIN) {
! 1213: rc = LIBSSH2_ERROR_EAGAIN;
! 1214: break;
! 1215: }
! 1216:
! 1217: (void)libssh2_session_last_error(sshc->ssh_session,
! 1218: &err_msg, NULL, 0);
! 1219: failf(data, "Failure initializing sftp session: %s", err_msg);
! 1220: state(conn, SSH_SESSION_FREE);
! 1221: sshc->actualcode = CURLE_FAILED_INIT;
! 1222: break;
! 1223: }
! 1224: state(conn, SSH_SFTP_REALPATH);
! 1225: break;
! 1226:
! 1227: case SSH_SFTP_REALPATH:
! 1228: {
! 1229: char tempHome[PATH_MAX];
! 1230:
! 1231: /*
! 1232: * Get the "home" directory
! 1233: */
! 1234: rc = sftp_libssh2_realpath(sshc->sftp_session, ".",
! 1235: tempHome, PATH_MAX-1);
! 1236: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1237: break;
! 1238: }
! 1239: if(rc > 0) {
! 1240: /* It seems that this string is not always NULL terminated */
! 1241: tempHome[rc] = '\0';
! 1242: sshc->homedir = strdup(tempHome);
! 1243: if(!sshc->homedir) {
! 1244: state(conn, SSH_SFTP_CLOSE);
! 1245: sshc->actualcode = CURLE_OUT_OF_MEMORY;
! 1246: break;
! 1247: }
! 1248: conn->data->state.most_recent_ftp_entrypath = sshc->homedir;
! 1249: }
! 1250: else {
! 1251: /* Return the error type */
! 1252: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1253: if(err)
! 1254: result = sftp_libssh2_error_to_CURLE(err);
! 1255: else
! 1256: /* in this case, the error wasn't in the SFTP level but for example
! 1257: a time-out or similar */
! 1258: result = CURLE_SSH;
! 1259: sshc->actualcode = result;
! 1260: DEBUGF(infof(data, "error = %d makes libcurl = %d\n",
! 1261: err, (int)result));
! 1262: state(conn, SSH_STOP);
! 1263: break;
! 1264: }
! 1265: }
! 1266: /* This is the last step in the SFTP connect phase. Do note that while
! 1267: we get the homedir here, we get the "workingpath" in the DO action
! 1268: since the homedir will remain the same between request but the
! 1269: working path will not. */
! 1270: DEBUGF(infof(data, "SSH CONNECT phase done\n"));
! 1271: state(conn, SSH_STOP);
! 1272: break;
! 1273:
! 1274: case SSH_SFTP_QUOTE_INIT:
! 1275:
! 1276: result = Curl_getworkingpath(conn, sshc->homedir, &sftp_scp->path);
! 1277: if(result) {
! 1278: sshc->actualcode = result;
! 1279: state(conn, SSH_STOP);
! 1280: break;
! 1281: }
! 1282:
! 1283: if(data->set.quote) {
! 1284: infof(data, "Sending quote commands\n");
! 1285: sshc->quote_item = data->set.quote;
! 1286: state(conn, SSH_SFTP_QUOTE);
! 1287: }
! 1288: else {
! 1289: state(conn, SSH_SFTP_GETINFO);
! 1290: }
! 1291: break;
! 1292:
! 1293: case SSH_SFTP_POSTQUOTE_INIT:
! 1294: if(data->set.postquote) {
! 1295: infof(data, "Sending quote commands\n");
! 1296: sshc->quote_item = data->set.postquote;
! 1297: state(conn, SSH_SFTP_QUOTE);
! 1298: }
! 1299: else {
! 1300: state(conn, SSH_STOP);
! 1301: }
! 1302: break;
! 1303:
! 1304: case SSH_SFTP_QUOTE:
! 1305: /* Send any quote commands */
! 1306: {
! 1307: const char *cp;
! 1308:
! 1309: /*
! 1310: * Support some of the "FTP" commands
! 1311: *
! 1312: * 'sshc->quote_item' is already verified to be non-NULL before it
! 1313: * switched to this state.
! 1314: */
! 1315: char *cmd = sshc->quote_item->data;
! 1316: sshc->acceptfail = FALSE;
! 1317:
! 1318: /* if a command starts with an asterisk, which a legal SFTP command never
! 1319: can, the command will be allowed to fail without it causing any
! 1320: aborts or cancels etc. It will cause libcurl to act as if the command
! 1321: is successful, whatever the server reponds. */
! 1322:
! 1323: if(cmd[0] == '*') {
! 1324: cmd++;
! 1325: sshc->acceptfail = TRUE;
! 1326: }
! 1327:
! 1328: if(strcasecompare("pwd", cmd)) {
! 1329: /* output debug output if that is requested */
! 1330: char *tmp = aprintf("257 \"%s\" is current directory.\n",
! 1331: sftp_scp->path);
! 1332: if(!tmp) {
! 1333: result = CURLE_OUT_OF_MEMORY;
! 1334: state(conn, SSH_SFTP_CLOSE);
! 1335: sshc->nextstate = SSH_NO_STATE;
! 1336: break;
! 1337: }
! 1338: if(data->set.verbose) {
! 1339: Curl_debug(data, CURLINFO_HEADER_OUT, (char *)"PWD\n", 4);
! 1340: Curl_debug(data, CURLINFO_HEADER_IN, tmp, strlen(tmp));
! 1341: }
! 1342: /* this sends an FTP-like "header" to the header callback so that the
! 1343: current directory can be read very similar to how it is read when
! 1344: using ordinary FTP. */
! 1345: result = Curl_client_write(conn, CLIENTWRITE_HEADER, tmp, strlen(tmp));
! 1346: free(tmp);
! 1347: if(result) {
! 1348: state(conn, SSH_SFTP_CLOSE);
! 1349: sshc->nextstate = SSH_NO_STATE;
! 1350: sshc->actualcode = result;
! 1351: }
! 1352: else
! 1353: state(conn, SSH_SFTP_NEXT_QUOTE);
! 1354: break;
! 1355: }
! 1356: {
! 1357: /*
! 1358: * the arguments following the command must be separated from the
! 1359: * command with a space so we can check for it unconditionally
! 1360: */
! 1361: cp = strchr(cmd, ' ');
! 1362: if(cp == NULL) {
! 1363: failf(data, "Syntax error in SFTP command. Supply parameter(s)!");
! 1364: state(conn, SSH_SFTP_CLOSE);
! 1365: sshc->nextstate = SSH_NO_STATE;
! 1366: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1367: break;
! 1368: }
! 1369:
! 1370: /*
! 1371: * also, every command takes at least one argument so we get that
! 1372: * first argument right now
! 1373: */
! 1374: result = Curl_get_pathname(&cp, &sshc->quote_path1, sshc->homedir);
! 1375: if(result) {
! 1376: if(result == CURLE_OUT_OF_MEMORY)
! 1377: failf(data, "Out of memory");
! 1378: else
! 1379: failf(data, "Syntax error: Bad first parameter");
! 1380: state(conn, SSH_SFTP_CLOSE);
! 1381: sshc->nextstate = SSH_NO_STATE;
! 1382: sshc->actualcode = result;
! 1383: break;
! 1384: }
! 1385:
! 1386: /*
! 1387: * SFTP is a binary protocol, so we don't send text commands
! 1388: * to the server. Instead, we scan for commands used by
! 1389: * OpenSSH's sftp program and call the appropriate libssh2
! 1390: * functions.
! 1391: */
! 1392: if(strncasecompare(cmd, "chgrp ", 6) ||
! 1393: strncasecompare(cmd, "chmod ", 6) ||
! 1394: strncasecompare(cmd, "chown ", 6) ) {
! 1395: /* attribute change */
! 1396:
! 1397: /* sshc->quote_path1 contains the mode to set */
! 1398: /* get the destination */
! 1399: result = Curl_get_pathname(&cp, &sshc->quote_path2, sshc->homedir);
! 1400: if(result) {
! 1401: if(result == CURLE_OUT_OF_MEMORY)
! 1402: failf(data, "Out of memory");
! 1403: else
! 1404: failf(data, "Syntax error in chgrp/chmod/chown: "
! 1405: "Bad second parameter");
! 1406: Curl_safefree(sshc->quote_path1);
! 1407: state(conn, SSH_SFTP_CLOSE);
! 1408: sshc->nextstate = SSH_NO_STATE;
! 1409: sshc->actualcode = result;
! 1410: break;
! 1411: }
! 1412: memset(&sshc->quote_attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES));
! 1413: state(conn, SSH_SFTP_QUOTE_STAT);
! 1414: break;
! 1415: }
! 1416: if(strncasecompare(cmd, "ln ", 3) ||
! 1417: strncasecompare(cmd, "symlink ", 8)) {
! 1418: /* symbolic linking */
! 1419: /* sshc->quote_path1 is the source */
! 1420: /* get the destination */
! 1421: result = Curl_get_pathname(&cp, &sshc->quote_path2, sshc->homedir);
! 1422: if(result) {
! 1423: if(result == CURLE_OUT_OF_MEMORY)
! 1424: failf(data, "Out of memory");
! 1425: else
! 1426: failf(data,
! 1427: "Syntax error in ln/symlink: Bad second parameter");
! 1428: Curl_safefree(sshc->quote_path1);
! 1429: state(conn, SSH_SFTP_CLOSE);
! 1430: sshc->nextstate = SSH_NO_STATE;
! 1431: sshc->actualcode = result;
! 1432: break;
! 1433: }
! 1434: state(conn, SSH_SFTP_QUOTE_SYMLINK);
! 1435: break;
! 1436: }
! 1437: else if(strncasecompare(cmd, "mkdir ", 6)) {
! 1438: /* create dir */
! 1439: state(conn, SSH_SFTP_QUOTE_MKDIR);
! 1440: break;
! 1441: }
! 1442: else if(strncasecompare(cmd, "rename ", 7)) {
! 1443: /* rename file */
! 1444: /* first param is the source path */
! 1445: /* second param is the dest. path */
! 1446: result = Curl_get_pathname(&cp, &sshc->quote_path2, sshc->homedir);
! 1447: if(result) {
! 1448: if(result == CURLE_OUT_OF_MEMORY)
! 1449: failf(data, "Out of memory");
! 1450: else
! 1451: failf(data, "Syntax error in rename: Bad second parameter");
! 1452: Curl_safefree(sshc->quote_path1);
! 1453: state(conn, SSH_SFTP_CLOSE);
! 1454: sshc->nextstate = SSH_NO_STATE;
! 1455: sshc->actualcode = result;
! 1456: break;
! 1457: }
! 1458: state(conn, SSH_SFTP_QUOTE_RENAME);
! 1459: break;
! 1460: }
! 1461: else if(strncasecompare(cmd, "rmdir ", 6)) {
! 1462: /* delete dir */
! 1463: state(conn, SSH_SFTP_QUOTE_RMDIR);
! 1464: break;
! 1465: }
! 1466: else if(strncasecompare(cmd, "rm ", 3)) {
! 1467: state(conn, SSH_SFTP_QUOTE_UNLINK);
! 1468: break;
! 1469: }
! 1470: #ifdef HAS_STATVFS_SUPPORT
! 1471: else if(strncasecompare(cmd, "statvfs ", 8)) {
! 1472: state(conn, SSH_SFTP_QUOTE_STATVFS);
! 1473: break;
! 1474: }
! 1475: #endif
! 1476:
! 1477: failf(data, "Unknown SFTP command");
! 1478: Curl_safefree(sshc->quote_path1);
! 1479: Curl_safefree(sshc->quote_path2);
! 1480: state(conn, SSH_SFTP_CLOSE);
! 1481: sshc->nextstate = SSH_NO_STATE;
! 1482: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1483: break;
! 1484: }
! 1485: }
! 1486: break;
! 1487:
! 1488: case SSH_SFTP_NEXT_QUOTE:
! 1489: Curl_safefree(sshc->quote_path1);
! 1490: Curl_safefree(sshc->quote_path2);
! 1491:
! 1492: sshc->quote_item = sshc->quote_item->next;
! 1493:
! 1494: if(sshc->quote_item) {
! 1495: state(conn, SSH_SFTP_QUOTE);
! 1496: }
! 1497: else {
! 1498: if(sshc->nextstate != SSH_NO_STATE) {
! 1499: state(conn, sshc->nextstate);
! 1500: sshc->nextstate = SSH_NO_STATE;
! 1501: }
! 1502: else {
! 1503: state(conn, SSH_SFTP_GETINFO);
! 1504: }
! 1505: }
! 1506: break;
! 1507:
! 1508: case SSH_SFTP_QUOTE_STAT:
! 1509: {
! 1510: char *cmd = sshc->quote_item->data;
! 1511: sshc->acceptfail = FALSE;
! 1512:
! 1513: /* if a command starts with an asterisk, which a legal SFTP command never
! 1514: can, the command will be allowed to fail without it causing any
! 1515: aborts or cancels etc. It will cause libcurl to act as if the command
! 1516: is successful, whatever the server reponds. */
! 1517:
! 1518: if(cmd[0] == '*') {
! 1519: cmd++;
! 1520: sshc->acceptfail = TRUE;
! 1521: }
! 1522:
! 1523: if(!strncasecompare(cmd, "chmod", 5)) {
! 1524: /* Since chown and chgrp only set owner OR group but libssh2 wants to
! 1525: * set them both at once, we need to obtain the current ownership
! 1526: * first. This takes an extra protocol round trip.
! 1527: */
! 1528: rc = libssh2_sftp_stat_ex(sshc->sftp_session, sshc->quote_path2,
! 1529: curlx_uztoui(strlen(sshc->quote_path2)),
! 1530: LIBSSH2_SFTP_STAT,
! 1531: &sshc->quote_attrs);
! 1532: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1533: break;
! 1534: }
! 1535: if(rc != 0 && !sshc->acceptfail) { /* get those attributes */
! 1536: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1537: Curl_safefree(sshc->quote_path1);
! 1538: Curl_safefree(sshc->quote_path2);
! 1539: failf(data, "Attempt to get SFTP stats failed: %s",
! 1540: sftp_libssh2_strerror(err));
! 1541: state(conn, SSH_SFTP_CLOSE);
! 1542: sshc->nextstate = SSH_NO_STATE;
! 1543: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1544: break;
! 1545: }
! 1546: }
! 1547:
! 1548: /* Now set the new attributes... */
! 1549: if(strncasecompare(cmd, "chgrp", 5)) {
! 1550: sshc->quote_attrs.gid = strtoul(sshc->quote_path1, NULL, 10);
! 1551: sshc->quote_attrs.flags = LIBSSH2_SFTP_ATTR_UIDGID;
! 1552: if(sshc->quote_attrs.gid == 0 && !ISDIGIT(sshc->quote_path1[0]) &&
! 1553: !sshc->acceptfail) {
! 1554: Curl_safefree(sshc->quote_path1);
! 1555: Curl_safefree(sshc->quote_path2);
! 1556: failf(data, "Syntax error: chgrp gid not a number");
! 1557: state(conn, SSH_SFTP_CLOSE);
! 1558: sshc->nextstate = SSH_NO_STATE;
! 1559: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1560: break;
! 1561: }
! 1562: }
! 1563: else if(strncasecompare(cmd, "chmod", 5)) {
! 1564: sshc->quote_attrs.permissions = strtoul(sshc->quote_path1, NULL, 8);
! 1565: sshc->quote_attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS;
! 1566: /* permissions are octal */
! 1567: if(sshc->quote_attrs.permissions == 0 &&
! 1568: !ISDIGIT(sshc->quote_path1[0])) {
! 1569: Curl_safefree(sshc->quote_path1);
! 1570: Curl_safefree(sshc->quote_path2);
! 1571: failf(data, "Syntax error: chmod permissions not a number");
! 1572: state(conn, SSH_SFTP_CLOSE);
! 1573: sshc->nextstate = SSH_NO_STATE;
! 1574: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1575: break;
! 1576: }
! 1577: }
! 1578: else if(strncasecompare(cmd, "chown", 5)) {
! 1579: sshc->quote_attrs.uid = strtoul(sshc->quote_path1, NULL, 10);
! 1580: sshc->quote_attrs.flags = LIBSSH2_SFTP_ATTR_UIDGID;
! 1581: if(sshc->quote_attrs.uid == 0 && !ISDIGIT(sshc->quote_path1[0]) &&
! 1582: !sshc->acceptfail) {
! 1583: Curl_safefree(sshc->quote_path1);
! 1584: Curl_safefree(sshc->quote_path2);
! 1585: failf(data, "Syntax error: chown uid not a number");
! 1586: state(conn, SSH_SFTP_CLOSE);
! 1587: sshc->nextstate = SSH_NO_STATE;
! 1588: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1589: break;
! 1590: }
! 1591: }
! 1592:
! 1593: /* Now send the completed structure... */
! 1594: state(conn, SSH_SFTP_QUOTE_SETSTAT);
! 1595: break;
! 1596: }
! 1597:
! 1598: case SSH_SFTP_QUOTE_SETSTAT:
! 1599: rc = libssh2_sftp_stat_ex(sshc->sftp_session, sshc->quote_path2,
! 1600: curlx_uztoui(strlen(sshc->quote_path2)),
! 1601: LIBSSH2_SFTP_SETSTAT,
! 1602: &sshc->quote_attrs);
! 1603: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1604: break;
! 1605: }
! 1606: if(rc != 0 && !sshc->acceptfail) {
! 1607: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1608: Curl_safefree(sshc->quote_path1);
! 1609: Curl_safefree(sshc->quote_path2);
! 1610: failf(data, "Attempt to set SFTP stats failed: %s",
! 1611: sftp_libssh2_strerror(err));
! 1612: state(conn, SSH_SFTP_CLOSE);
! 1613: sshc->nextstate = SSH_NO_STATE;
! 1614: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1615: break;
! 1616: }
! 1617: state(conn, SSH_SFTP_NEXT_QUOTE);
! 1618: break;
! 1619:
! 1620: case SSH_SFTP_QUOTE_SYMLINK:
! 1621: rc = libssh2_sftp_symlink_ex(sshc->sftp_session, sshc->quote_path1,
! 1622: curlx_uztoui(strlen(sshc->quote_path1)),
! 1623: sshc->quote_path2,
! 1624: curlx_uztoui(strlen(sshc->quote_path2)),
! 1625: LIBSSH2_SFTP_SYMLINK);
! 1626: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1627: break;
! 1628: }
! 1629: if(rc != 0 && !sshc->acceptfail) {
! 1630: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1631: Curl_safefree(sshc->quote_path1);
! 1632: Curl_safefree(sshc->quote_path2);
! 1633: failf(data, "symlink command failed: %s",
! 1634: sftp_libssh2_strerror(err));
! 1635: state(conn, SSH_SFTP_CLOSE);
! 1636: sshc->nextstate = SSH_NO_STATE;
! 1637: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1638: break;
! 1639: }
! 1640: state(conn, SSH_SFTP_NEXT_QUOTE);
! 1641: break;
! 1642:
! 1643: case SSH_SFTP_QUOTE_MKDIR:
! 1644: rc = libssh2_sftp_mkdir_ex(sshc->sftp_session, sshc->quote_path1,
! 1645: curlx_uztoui(strlen(sshc->quote_path1)),
! 1646: data->set.new_directory_perms);
! 1647: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1648: break;
! 1649: }
! 1650: if(rc != 0 && !sshc->acceptfail) {
! 1651: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1652: Curl_safefree(sshc->quote_path1);
! 1653: failf(data, "mkdir command failed: %s", sftp_libssh2_strerror(err));
! 1654: state(conn, SSH_SFTP_CLOSE);
! 1655: sshc->nextstate = SSH_NO_STATE;
! 1656: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1657: break;
! 1658: }
! 1659: state(conn, SSH_SFTP_NEXT_QUOTE);
! 1660: break;
! 1661:
! 1662: case SSH_SFTP_QUOTE_RENAME:
! 1663: rc = libssh2_sftp_rename_ex(sshc->sftp_session, sshc->quote_path1,
! 1664: curlx_uztoui(strlen(sshc->quote_path1)),
! 1665: sshc->quote_path2,
! 1666: curlx_uztoui(strlen(sshc->quote_path2)),
! 1667: LIBSSH2_SFTP_RENAME_OVERWRITE |
! 1668: LIBSSH2_SFTP_RENAME_ATOMIC |
! 1669: LIBSSH2_SFTP_RENAME_NATIVE);
! 1670:
! 1671: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1672: break;
! 1673: }
! 1674: if(rc != 0 && !sshc->acceptfail) {
! 1675: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1676: Curl_safefree(sshc->quote_path1);
! 1677: Curl_safefree(sshc->quote_path2);
! 1678: failf(data, "rename command failed: %s", sftp_libssh2_strerror(err));
! 1679: state(conn, SSH_SFTP_CLOSE);
! 1680: sshc->nextstate = SSH_NO_STATE;
! 1681: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1682: break;
! 1683: }
! 1684: state(conn, SSH_SFTP_NEXT_QUOTE);
! 1685: break;
! 1686:
! 1687: case SSH_SFTP_QUOTE_RMDIR:
! 1688: rc = libssh2_sftp_rmdir_ex(sshc->sftp_session, sshc->quote_path1,
! 1689: curlx_uztoui(strlen(sshc->quote_path1)));
! 1690: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1691: break;
! 1692: }
! 1693: if(rc != 0 && !sshc->acceptfail) {
! 1694: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1695: Curl_safefree(sshc->quote_path1);
! 1696: failf(data, "rmdir command failed: %s", sftp_libssh2_strerror(err));
! 1697: state(conn, SSH_SFTP_CLOSE);
! 1698: sshc->nextstate = SSH_NO_STATE;
! 1699: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1700: break;
! 1701: }
! 1702: state(conn, SSH_SFTP_NEXT_QUOTE);
! 1703: break;
! 1704:
! 1705: case SSH_SFTP_QUOTE_UNLINK:
! 1706: rc = libssh2_sftp_unlink_ex(sshc->sftp_session, sshc->quote_path1,
! 1707: curlx_uztoui(strlen(sshc->quote_path1)));
! 1708: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1709: break;
! 1710: }
! 1711: if(rc != 0 && !sshc->acceptfail) {
! 1712: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1713: Curl_safefree(sshc->quote_path1);
! 1714: failf(data, "rm command failed: %s", sftp_libssh2_strerror(err));
! 1715: state(conn, SSH_SFTP_CLOSE);
! 1716: sshc->nextstate = SSH_NO_STATE;
! 1717: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1718: break;
! 1719: }
! 1720: state(conn, SSH_SFTP_NEXT_QUOTE);
! 1721: break;
! 1722:
! 1723: #ifdef HAS_STATVFS_SUPPORT
! 1724: case SSH_SFTP_QUOTE_STATVFS:
! 1725: {
! 1726: LIBSSH2_SFTP_STATVFS statvfs;
! 1727: rc = libssh2_sftp_statvfs(sshc->sftp_session, sshc->quote_path1,
! 1728: curlx_uztoui(strlen(sshc->quote_path1)),
! 1729: &statvfs);
! 1730:
! 1731: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1732: break;
! 1733: }
! 1734: if(rc != 0 && !sshc->acceptfail) {
! 1735: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1736: Curl_safefree(sshc->quote_path1);
! 1737: failf(data, "statvfs command failed: %s", sftp_libssh2_strerror(err));
! 1738: state(conn, SSH_SFTP_CLOSE);
! 1739: sshc->nextstate = SSH_NO_STATE;
! 1740: sshc->actualcode = CURLE_QUOTE_ERROR;
! 1741: break;
! 1742: }
! 1743: else if(rc == 0) {
! 1744: char *tmp = aprintf("statvfs:\n"
! 1745: "f_bsize: %llu\n" "f_frsize: %llu\n"
! 1746: "f_blocks: %llu\n" "f_bfree: %llu\n"
! 1747: "f_bavail: %llu\n" "f_files: %llu\n"
! 1748: "f_ffree: %llu\n" "f_favail: %llu\n"
! 1749: "f_fsid: %llu\n" "f_flag: %llu\n"
! 1750: "f_namemax: %llu\n",
! 1751: statvfs.f_bsize, statvfs.f_frsize,
! 1752: statvfs.f_blocks, statvfs.f_bfree,
! 1753: statvfs.f_bavail, statvfs.f_files,
! 1754: statvfs.f_ffree, statvfs.f_favail,
! 1755: statvfs.f_fsid, statvfs.f_flag,
! 1756: statvfs.f_namemax);
! 1757: if(!tmp) {
! 1758: result = CURLE_OUT_OF_MEMORY;
! 1759: state(conn, SSH_SFTP_CLOSE);
! 1760: sshc->nextstate = SSH_NO_STATE;
! 1761: break;
! 1762: }
! 1763:
! 1764: result = Curl_client_write(conn, CLIENTWRITE_HEADER, tmp, strlen(tmp));
! 1765: free(tmp);
! 1766: if(result) {
! 1767: state(conn, SSH_SFTP_CLOSE);
! 1768: sshc->nextstate = SSH_NO_STATE;
! 1769: sshc->actualcode = result;
! 1770: }
! 1771: }
! 1772: state(conn, SSH_SFTP_NEXT_QUOTE);
! 1773: break;
! 1774: }
! 1775: #endif
! 1776: case SSH_SFTP_GETINFO:
! 1777: {
! 1778: if(data->set.get_filetime) {
! 1779: state(conn, SSH_SFTP_FILETIME);
! 1780: }
! 1781: else {
! 1782: state(conn, SSH_SFTP_TRANS_INIT);
! 1783: }
! 1784: break;
! 1785: }
! 1786:
! 1787: case SSH_SFTP_FILETIME:
! 1788: {
! 1789: LIBSSH2_SFTP_ATTRIBUTES attrs;
! 1790:
! 1791: rc = libssh2_sftp_stat_ex(sshc->sftp_session, sftp_scp->path,
! 1792: curlx_uztoui(strlen(sftp_scp->path)),
! 1793: LIBSSH2_SFTP_STAT, &attrs);
! 1794: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1795: break;
! 1796: }
! 1797: if(rc == 0) {
! 1798: data->info.filetime = attrs.mtime;
! 1799: }
! 1800:
! 1801: state(conn, SSH_SFTP_TRANS_INIT);
! 1802: break;
! 1803: }
! 1804:
! 1805: case SSH_SFTP_TRANS_INIT:
! 1806: if(data->set.upload)
! 1807: state(conn, SSH_SFTP_UPLOAD_INIT);
! 1808: else {
! 1809: if(sftp_scp->path[strlen(sftp_scp->path)-1] == '/')
! 1810: state(conn, SSH_SFTP_READDIR_INIT);
! 1811: else
! 1812: state(conn, SSH_SFTP_DOWNLOAD_INIT);
! 1813: }
! 1814: break;
! 1815:
! 1816: case SSH_SFTP_UPLOAD_INIT:
! 1817: {
! 1818: unsigned long flags;
! 1819: /*
! 1820: * NOTE!!! libssh2 requires that the destination path is a full path
! 1821: * that includes the destination file and name OR ends in a "/"
! 1822: * If this is not done the destination file will be named the
! 1823: * same name as the last directory in the path.
! 1824: */
! 1825:
! 1826: if(data->state.resume_from != 0) {
! 1827: LIBSSH2_SFTP_ATTRIBUTES attrs;
! 1828: if(data->state.resume_from < 0) {
! 1829: rc = libssh2_sftp_stat_ex(sshc->sftp_session, sftp_scp->path,
! 1830: curlx_uztoui(strlen(sftp_scp->path)),
! 1831: LIBSSH2_SFTP_STAT, &attrs);
! 1832: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 1833: break;
! 1834: }
! 1835: if(rc) {
! 1836: data->state.resume_from = 0;
! 1837: }
! 1838: else {
! 1839: curl_off_t size = attrs.filesize;
! 1840: if(size < 0) {
! 1841: failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size);
! 1842: return CURLE_BAD_DOWNLOAD_RESUME;
! 1843: }
! 1844: data->state.resume_from = attrs.filesize;
! 1845: }
! 1846: }
! 1847: }
! 1848:
! 1849: if(data->set.ftp_append)
! 1850: /* Try to open for append, but create if nonexisting */
! 1851: flags = LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|LIBSSH2_FXF_APPEND;
! 1852: else if(data->state.resume_from > 0)
! 1853: /* If we have restart position then open for append */
! 1854: flags = LIBSSH2_FXF_WRITE|LIBSSH2_FXF_APPEND;
! 1855: else
! 1856: /* Clear file before writing (normal behaviour) */
! 1857: flags = LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|LIBSSH2_FXF_TRUNC;
! 1858:
! 1859: sshc->sftp_handle =
! 1860: libssh2_sftp_open_ex(sshc->sftp_session, sftp_scp->path,
! 1861: curlx_uztoui(strlen(sftp_scp->path)),
! 1862: flags, data->set.new_file_perms,
! 1863: LIBSSH2_SFTP_OPENFILE);
! 1864:
! 1865: if(!sshc->sftp_handle) {
! 1866: rc = libssh2_session_last_errno(sshc->ssh_session);
! 1867:
! 1868: if(LIBSSH2_ERROR_EAGAIN == rc)
! 1869: break;
! 1870:
! 1871: if(LIBSSH2_ERROR_SFTP_PROTOCOL == rc)
! 1872: /* only when there was an SFTP protocol error can we extract
! 1873: the sftp error! */
! 1874: err = sftp_libssh2_last_error(sshc->sftp_session);
! 1875: else
! 1876: err = -1; /* not an sftp error at all */
! 1877:
! 1878: if(sshc->secondCreateDirs) {
! 1879: state(conn, SSH_SFTP_CLOSE);
! 1880: sshc->actualcode = err>= LIBSSH2_FX_OK?
! 1881: sftp_libssh2_error_to_CURLE(err):CURLE_SSH;
! 1882: failf(data, "Creating the dir/file failed: %s",
! 1883: sftp_libssh2_strerror(err));
! 1884: break;
! 1885: }
! 1886: if(((err == LIBSSH2_FX_NO_SUCH_FILE) ||
! 1887: (err == LIBSSH2_FX_FAILURE) ||
! 1888: (err == LIBSSH2_FX_NO_SUCH_PATH)) &&
! 1889: (data->set.ftp_create_missing_dirs &&
! 1890: (strlen(sftp_scp->path) > 1))) {
! 1891: /* try to create the path remotely */
! 1892: rc = 0; /* clear rc and continue */
! 1893: sshc->secondCreateDirs = 1;
! 1894: state(conn, SSH_SFTP_CREATE_DIRS_INIT);
! 1895: break;
! 1896: }
! 1897: state(conn, SSH_SFTP_CLOSE);
! 1898: sshc->actualcode = err>= LIBSSH2_FX_OK?
! 1899: sftp_libssh2_error_to_CURLE(err):CURLE_SSH;
! 1900: if(!sshc->actualcode) {
! 1901: /* Sometimes, for some reason libssh2_sftp_last_error() returns
! 1902: zero even though libssh2_sftp_open() failed previously! We need
! 1903: to work around that! */
! 1904: sshc->actualcode = CURLE_SSH;
! 1905: err = -1;
! 1906: }
! 1907: failf(data, "Upload failed: %s (%d/%d)",
! 1908: err>= LIBSSH2_FX_OK?sftp_libssh2_strerror(err):"ssh error",
! 1909: err, rc);
! 1910: break;
! 1911: }
! 1912:
! 1913: /* If we have a restart point then we need to seek to the correct
! 1914: position. */
! 1915: if(data->state.resume_from > 0) {
! 1916: /* Let's read off the proper amount of bytes from the input. */
! 1917: if(conn->seek_func) {
! 1918: Curl_set_in_callback(data, true);
! 1919: seekerr = conn->seek_func(conn->seek_client, data->state.resume_from,
! 1920: SEEK_SET);
! 1921: Curl_set_in_callback(data, false);
! 1922: }
! 1923:
! 1924: if(seekerr != CURL_SEEKFUNC_OK) {
! 1925: curl_off_t passed = 0;
! 1926:
! 1927: if(seekerr != CURL_SEEKFUNC_CANTSEEK) {
! 1928: failf(data, "Could not seek stream");
! 1929: return CURLE_FTP_COULDNT_USE_REST;
! 1930: }
! 1931: /* seekerr == CURL_SEEKFUNC_CANTSEEK (can't seek to offset) */
! 1932: do {
! 1933: size_t readthisamountnow =
! 1934: (data->state.resume_from - passed > data->set.buffer_size) ?
! 1935: (size_t)data->set.buffer_size :
! 1936: curlx_sotouz(data->state.resume_from - passed);
! 1937:
! 1938: size_t actuallyread;
! 1939: Curl_set_in_callback(data, true);
! 1940: actuallyread = data->state.fread_func(data->state.buffer, 1,
! 1941: readthisamountnow,
! 1942: data->state.in);
! 1943: Curl_set_in_callback(data, false);
! 1944:
! 1945: passed += actuallyread;
! 1946: if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
! 1947: /* this checks for greater-than only to make sure that the
! 1948: CURL_READFUNC_ABORT return code still aborts */
! 1949: failf(data, "Failed to read data");
! 1950: return CURLE_FTP_COULDNT_USE_REST;
! 1951: }
! 1952: } while(passed < data->state.resume_from);
! 1953: }
! 1954:
! 1955: /* now, decrease the size of the read */
! 1956: if(data->state.infilesize > 0) {
! 1957: data->state.infilesize -= data->state.resume_from;
! 1958: data->req.size = data->state.infilesize;
! 1959: Curl_pgrsSetUploadSize(data, data->state.infilesize);
! 1960: }
! 1961:
! 1962: SFTP_SEEK(sshc->sftp_handle, data->state.resume_from);
! 1963: }
! 1964: if(data->state.infilesize > 0) {
! 1965: data->req.size = data->state.infilesize;
! 1966: Curl_pgrsSetUploadSize(data, data->state.infilesize);
! 1967: }
! 1968: /* upload data */
! 1969: Curl_setup_transfer(data, -1, -1, FALSE, FIRSTSOCKET);
! 1970:
! 1971: /* not set by Curl_setup_transfer to preserve keepon bits */
! 1972: conn->sockfd = conn->writesockfd;
! 1973:
! 1974: if(result) {
! 1975: state(conn, SSH_SFTP_CLOSE);
! 1976: sshc->actualcode = result;
! 1977: }
! 1978: else {
! 1979: /* store this original bitmask setup to use later on if we can't
! 1980: figure out a "real" bitmask */
! 1981: sshc->orig_waitfor = data->req.keepon;
! 1982:
! 1983: /* we want to use the _sending_ function even when the socket turns
! 1984: out readable as the underlying libssh2 sftp send function will deal
! 1985: with both accordingly */
! 1986: conn->cselect_bits = CURL_CSELECT_OUT;
! 1987:
! 1988: /* since we don't really wait for anything at this point, we want the
! 1989: state machine to move on as soon as possible so we set a very short
! 1990: timeout here */
! 1991: Curl_expire(data, 0, EXPIRE_RUN_NOW);
! 1992:
! 1993: state(conn, SSH_STOP);
! 1994: }
! 1995: break;
! 1996: }
! 1997:
! 1998: case SSH_SFTP_CREATE_DIRS_INIT:
! 1999: if(strlen(sftp_scp->path) > 1) {
! 2000: sshc->slash_pos = sftp_scp->path + 1; /* ignore the leading '/' */
! 2001: state(conn, SSH_SFTP_CREATE_DIRS);
! 2002: }
! 2003: else {
! 2004: state(conn, SSH_SFTP_UPLOAD_INIT);
! 2005: }
! 2006: break;
! 2007:
! 2008: case SSH_SFTP_CREATE_DIRS:
! 2009: sshc->slash_pos = strchr(sshc->slash_pos, '/');
! 2010: if(sshc->slash_pos) {
! 2011: *sshc->slash_pos = 0;
! 2012:
! 2013: infof(data, "Creating directory '%s'\n", sftp_scp->path);
! 2014: state(conn, SSH_SFTP_CREATE_DIRS_MKDIR);
! 2015: break;
! 2016: }
! 2017: state(conn, SSH_SFTP_UPLOAD_INIT);
! 2018: break;
! 2019:
! 2020: case SSH_SFTP_CREATE_DIRS_MKDIR:
! 2021: /* 'mode' - parameter is preliminary - default to 0644 */
! 2022: rc = libssh2_sftp_mkdir_ex(sshc->sftp_session, sftp_scp->path,
! 2023: curlx_uztoui(strlen(sftp_scp->path)),
! 2024: data->set.new_directory_perms);
! 2025: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2026: break;
! 2027: }
! 2028: *sshc->slash_pos = '/';
! 2029: ++sshc->slash_pos;
! 2030: if(rc < 0) {
! 2031: /*
! 2032: * Abort if failure wasn't that the dir already exists or the
! 2033: * permission was denied (creation might succeed further down the
! 2034: * path) - retry on unspecific FAILURE also
! 2035: */
! 2036: err = sftp_libssh2_last_error(sshc->sftp_session);
! 2037: if((err != LIBSSH2_FX_FILE_ALREADY_EXISTS) &&
! 2038: (err != LIBSSH2_FX_FAILURE) &&
! 2039: (err != LIBSSH2_FX_PERMISSION_DENIED)) {
! 2040: result = sftp_libssh2_error_to_CURLE(err);
! 2041: state(conn, SSH_SFTP_CLOSE);
! 2042: sshc->actualcode = result?result:CURLE_SSH;
! 2043: break;
! 2044: }
! 2045: rc = 0; /* clear rc and continue */
! 2046: }
! 2047: state(conn, SSH_SFTP_CREATE_DIRS);
! 2048: break;
! 2049:
! 2050: case SSH_SFTP_READDIR_INIT:
! 2051: Curl_pgrsSetDownloadSize(data, -1);
! 2052: if(data->set.opt_no_body) {
! 2053: state(conn, SSH_STOP);
! 2054: break;
! 2055: }
! 2056:
! 2057: /*
! 2058: * This is a directory that we are trying to get, so produce a directory
! 2059: * listing
! 2060: */
! 2061: sshc->sftp_handle = libssh2_sftp_open_ex(sshc->sftp_session,
! 2062: sftp_scp->path,
! 2063: curlx_uztoui(
! 2064: strlen(sftp_scp->path)),
! 2065: 0, 0, LIBSSH2_SFTP_OPENDIR);
! 2066: if(!sshc->sftp_handle) {
! 2067: if(libssh2_session_last_errno(sshc->ssh_session) ==
! 2068: LIBSSH2_ERROR_EAGAIN) {
! 2069: rc = LIBSSH2_ERROR_EAGAIN;
! 2070: break;
! 2071: }
! 2072: err = sftp_libssh2_last_error(sshc->sftp_session);
! 2073: failf(data, "Could not open directory for reading: %s",
! 2074: sftp_libssh2_strerror(err));
! 2075: state(conn, SSH_SFTP_CLOSE);
! 2076: result = sftp_libssh2_error_to_CURLE(err);
! 2077: sshc->actualcode = result?result:CURLE_SSH;
! 2078: break;
! 2079: }
! 2080: sshc->readdir_filename = malloc(PATH_MAX + 1);
! 2081: if(!sshc->readdir_filename) {
! 2082: state(conn, SSH_SFTP_CLOSE);
! 2083: sshc->actualcode = CURLE_OUT_OF_MEMORY;
! 2084: break;
! 2085: }
! 2086: sshc->readdir_longentry = malloc(PATH_MAX + 1);
! 2087: if(!sshc->readdir_longentry) {
! 2088: Curl_safefree(sshc->readdir_filename);
! 2089: state(conn, SSH_SFTP_CLOSE);
! 2090: sshc->actualcode = CURLE_OUT_OF_MEMORY;
! 2091: break;
! 2092: }
! 2093: state(conn, SSH_SFTP_READDIR);
! 2094: break;
! 2095:
! 2096: case SSH_SFTP_READDIR:
! 2097: rc = libssh2_sftp_readdir_ex(sshc->sftp_handle,
! 2098: sshc->readdir_filename,
! 2099: PATH_MAX,
! 2100: sshc->readdir_longentry,
! 2101: PATH_MAX,
! 2102: &sshc->readdir_attrs);
! 2103: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2104: break;
! 2105: }
! 2106: if(rc > 0) {
! 2107: sshc->readdir_len = (size_t) rc;
! 2108: sshc->readdir_filename[sshc->readdir_len] = '\0';
! 2109:
! 2110: if(data->set.ftp_list_only) {
! 2111: char *tmpLine;
! 2112:
! 2113: tmpLine = aprintf("%s\n", sshc->readdir_filename);
! 2114: if(tmpLine == NULL) {
! 2115: state(conn, SSH_SFTP_CLOSE);
! 2116: sshc->actualcode = CURLE_OUT_OF_MEMORY;
! 2117: break;
! 2118: }
! 2119: result = Curl_client_write(conn, CLIENTWRITE_BODY,
! 2120: tmpLine, sshc->readdir_len + 1);
! 2121: free(tmpLine);
! 2122:
! 2123: if(result) {
! 2124: state(conn, SSH_STOP);
! 2125: break;
! 2126: }
! 2127: /* since this counts what we send to the client, we include the
! 2128: newline in this counter */
! 2129: data->req.bytecount += sshc->readdir_len + 1;
! 2130:
! 2131: /* output debug output if that is requested */
! 2132: if(data->set.verbose) {
! 2133: Curl_debug(data, CURLINFO_DATA_OUT, sshc->readdir_filename,
! 2134: sshc->readdir_len);
! 2135: }
! 2136: }
! 2137: else {
! 2138: sshc->readdir_currLen = strlen(sshc->readdir_longentry);
! 2139: sshc->readdir_totalLen = 80 + sshc->readdir_currLen;
! 2140: sshc->readdir_line = calloc(sshc->readdir_totalLen, 1);
! 2141: if(!sshc->readdir_line) {
! 2142: Curl_safefree(sshc->readdir_filename);
! 2143: Curl_safefree(sshc->readdir_longentry);
! 2144: state(conn, SSH_SFTP_CLOSE);
! 2145: sshc->actualcode = CURLE_OUT_OF_MEMORY;
! 2146: break;
! 2147: }
! 2148:
! 2149: memcpy(sshc->readdir_line, sshc->readdir_longentry,
! 2150: sshc->readdir_currLen);
! 2151: if((sshc->readdir_attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) &&
! 2152: ((sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
! 2153: LIBSSH2_SFTP_S_IFLNK)) {
! 2154: sshc->readdir_linkPath = malloc(PATH_MAX + 1);
! 2155: if(sshc->readdir_linkPath == NULL) {
! 2156: Curl_safefree(sshc->readdir_filename);
! 2157: Curl_safefree(sshc->readdir_longentry);
! 2158: state(conn, SSH_SFTP_CLOSE);
! 2159: sshc->actualcode = CURLE_OUT_OF_MEMORY;
! 2160: break;
! 2161: }
! 2162:
! 2163: msnprintf(sshc->readdir_linkPath, PATH_MAX, "%s%s", sftp_scp->path,
! 2164: sshc->readdir_filename);
! 2165: state(conn, SSH_SFTP_READDIR_LINK);
! 2166: break;
! 2167: }
! 2168: state(conn, SSH_SFTP_READDIR_BOTTOM);
! 2169: break;
! 2170: }
! 2171: }
! 2172: else if(rc == 0) {
! 2173: Curl_safefree(sshc->readdir_filename);
! 2174: Curl_safefree(sshc->readdir_longentry);
! 2175: state(conn, SSH_SFTP_READDIR_DONE);
! 2176: break;
! 2177: }
! 2178: else if(rc < 0) {
! 2179: err = sftp_libssh2_last_error(sshc->sftp_session);
! 2180: result = sftp_libssh2_error_to_CURLE(err);
! 2181: sshc->actualcode = result?result:CURLE_SSH;
! 2182: failf(data, "Could not open remote file for reading: %s :: %d",
! 2183: sftp_libssh2_strerror(err),
! 2184: libssh2_session_last_errno(sshc->ssh_session));
! 2185: Curl_safefree(sshc->readdir_filename);
! 2186: Curl_safefree(sshc->readdir_longentry);
! 2187: state(conn, SSH_SFTP_CLOSE);
! 2188: break;
! 2189: }
! 2190: break;
! 2191:
! 2192: case SSH_SFTP_READDIR_LINK:
! 2193: rc =
! 2194: libssh2_sftp_symlink_ex(sshc->sftp_session,
! 2195: sshc->readdir_linkPath,
! 2196: curlx_uztoui(strlen(sshc->readdir_linkPath)),
! 2197: sshc->readdir_filename,
! 2198: PATH_MAX, LIBSSH2_SFTP_READLINK);
! 2199: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2200: break;
! 2201: }
! 2202: sshc->readdir_len = (size_t) rc;
! 2203: Curl_safefree(sshc->readdir_linkPath);
! 2204:
! 2205: /* get room for the filename and extra output */
! 2206: sshc->readdir_totalLen += 4 + sshc->readdir_len;
! 2207: new_readdir_line = Curl_saferealloc(sshc->readdir_line,
! 2208: sshc->readdir_totalLen);
! 2209: if(!new_readdir_line) {
! 2210: sshc->readdir_line = NULL;
! 2211: Curl_safefree(sshc->readdir_filename);
! 2212: Curl_safefree(sshc->readdir_longentry);
! 2213: state(conn, SSH_SFTP_CLOSE);
! 2214: sshc->actualcode = CURLE_OUT_OF_MEMORY;
! 2215: break;
! 2216: }
! 2217: sshc->readdir_line = new_readdir_line;
! 2218:
! 2219: sshc->readdir_currLen += msnprintf(sshc->readdir_line +
! 2220: sshc->readdir_currLen,
! 2221: sshc->readdir_totalLen -
! 2222: sshc->readdir_currLen,
! 2223: " -> %s",
! 2224: sshc->readdir_filename);
! 2225:
! 2226: state(conn, SSH_SFTP_READDIR_BOTTOM);
! 2227: break;
! 2228:
! 2229: case SSH_SFTP_READDIR_BOTTOM:
! 2230: sshc->readdir_currLen += msnprintf(sshc->readdir_line +
! 2231: sshc->readdir_currLen,
! 2232: sshc->readdir_totalLen -
! 2233: sshc->readdir_currLen, "\n");
! 2234: result = Curl_client_write(conn, CLIENTWRITE_BODY,
! 2235: sshc->readdir_line,
! 2236: sshc->readdir_currLen);
! 2237:
! 2238: if(!result) {
! 2239:
! 2240: /* output debug output if that is requested */
! 2241: if(data->set.verbose) {
! 2242: Curl_debug(data, CURLINFO_DATA_OUT, sshc->readdir_line,
! 2243: sshc->readdir_currLen);
! 2244: }
! 2245: data->req.bytecount += sshc->readdir_currLen;
! 2246: }
! 2247: Curl_safefree(sshc->readdir_line);
! 2248: if(result) {
! 2249: state(conn, SSH_STOP);
! 2250: }
! 2251: else
! 2252: state(conn, SSH_SFTP_READDIR);
! 2253: break;
! 2254:
! 2255: case SSH_SFTP_READDIR_DONE:
! 2256: if(libssh2_sftp_closedir(sshc->sftp_handle) ==
! 2257: LIBSSH2_ERROR_EAGAIN) {
! 2258: rc = LIBSSH2_ERROR_EAGAIN;
! 2259: break;
! 2260: }
! 2261: sshc->sftp_handle = NULL;
! 2262: Curl_safefree(sshc->readdir_filename);
! 2263: Curl_safefree(sshc->readdir_longentry);
! 2264:
! 2265: /* no data to transfer */
! 2266: Curl_setup_transfer(data, -1, -1, FALSE, -1);
! 2267: state(conn, SSH_STOP);
! 2268: break;
! 2269:
! 2270: case SSH_SFTP_DOWNLOAD_INIT:
! 2271: /*
! 2272: * Work on getting the specified file
! 2273: */
! 2274: sshc->sftp_handle =
! 2275: libssh2_sftp_open_ex(sshc->sftp_session, sftp_scp->path,
! 2276: curlx_uztoui(strlen(sftp_scp->path)),
! 2277: LIBSSH2_FXF_READ, data->set.new_file_perms,
! 2278: LIBSSH2_SFTP_OPENFILE);
! 2279: if(!sshc->sftp_handle) {
! 2280: if(libssh2_session_last_errno(sshc->ssh_session) ==
! 2281: LIBSSH2_ERROR_EAGAIN) {
! 2282: rc = LIBSSH2_ERROR_EAGAIN;
! 2283: break;
! 2284: }
! 2285: err = sftp_libssh2_last_error(sshc->sftp_session);
! 2286: failf(data, "Could not open remote file for reading: %s",
! 2287: sftp_libssh2_strerror(err));
! 2288: state(conn, SSH_SFTP_CLOSE);
! 2289: result = sftp_libssh2_error_to_CURLE(err);
! 2290: sshc->actualcode = result?result:CURLE_SSH;
! 2291: break;
! 2292: }
! 2293: state(conn, SSH_SFTP_DOWNLOAD_STAT);
! 2294: break;
! 2295:
! 2296: case SSH_SFTP_DOWNLOAD_STAT:
! 2297: {
! 2298: LIBSSH2_SFTP_ATTRIBUTES attrs;
! 2299:
! 2300: rc = libssh2_sftp_stat_ex(sshc->sftp_session, sftp_scp->path,
! 2301: curlx_uztoui(strlen(sftp_scp->path)),
! 2302: LIBSSH2_SFTP_STAT, &attrs);
! 2303: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2304: break;
! 2305: }
! 2306: if(rc ||
! 2307: !(attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) ||
! 2308: (attrs.filesize == 0)) {
! 2309: /*
! 2310: * libssh2_sftp_open() didn't return an error, so maybe the server
! 2311: * just doesn't support stat()
! 2312: * OR the server doesn't return a file size with a stat()
! 2313: * OR file size is 0
! 2314: */
! 2315: data->req.size = -1;
! 2316: data->req.maxdownload = -1;
! 2317: Curl_pgrsSetDownloadSize(data, -1);
! 2318: }
! 2319: else {
! 2320: curl_off_t size = attrs.filesize;
! 2321:
! 2322: if(size < 0) {
! 2323: failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size);
! 2324: return CURLE_BAD_DOWNLOAD_RESUME;
! 2325: }
! 2326: if(conn->data->state.use_range) {
! 2327: curl_off_t from, to;
! 2328: char *ptr;
! 2329: char *ptr2;
! 2330: CURLofft to_t;
! 2331: CURLofft from_t;
! 2332:
! 2333: from_t = curlx_strtoofft(conn->data->state.range, &ptr, 0, &from);
! 2334: if(from_t == CURL_OFFT_FLOW)
! 2335: return CURLE_RANGE_ERROR;
! 2336: while(*ptr && (ISSPACE(*ptr) || (*ptr == '-')))
! 2337: ptr++;
! 2338: to_t = curlx_strtoofft(ptr, &ptr2, 0, &to);
! 2339: if(to_t == CURL_OFFT_FLOW)
! 2340: return CURLE_RANGE_ERROR;
! 2341: if((to_t == CURL_OFFT_INVAL) /* no "to" value given */
! 2342: || (to >= size)) {
! 2343: to = size - 1;
! 2344: }
! 2345: if(from_t) {
! 2346: /* from is relative to end of file */
! 2347: from = size - to;
! 2348: to = size - 1;
! 2349: }
! 2350: if(from > size) {
! 2351: failf(data, "Offset (%"
! 2352: CURL_FORMAT_CURL_OFF_T ") was beyond file size (%"
! 2353: CURL_FORMAT_CURL_OFF_T ")", from, attrs.filesize);
! 2354: return CURLE_BAD_DOWNLOAD_RESUME;
! 2355: }
! 2356: if(from > to) {
! 2357: from = to;
! 2358: size = 0;
! 2359: }
! 2360: else {
! 2361: size = to - from + 1;
! 2362: }
! 2363:
! 2364: SFTP_SEEK(conn->proto.sshc.sftp_handle, from);
! 2365: }
! 2366: data->req.size = size;
! 2367: data->req.maxdownload = size;
! 2368: Curl_pgrsSetDownloadSize(data, size);
! 2369: }
! 2370:
! 2371: /* We can resume if we can seek to the resume position */
! 2372: if(data->state.resume_from) {
! 2373: if(data->state.resume_from < 0) {
! 2374: /* We're supposed to download the last abs(from) bytes */
! 2375: if((curl_off_t)attrs.filesize < -data->state.resume_from) {
! 2376: failf(data, "Offset (%"
! 2377: CURL_FORMAT_CURL_OFF_T ") was beyond file size (%"
! 2378: CURL_FORMAT_CURL_OFF_T ")",
! 2379: data->state.resume_from, attrs.filesize);
! 2380: return CURLE_BAD_DOWNLOAD_RESUME;
! 2381: }
! 2382: /* download from where? */
! 2383: data->state.resume_from += attrs.filesize;
! 2384: }
! 2385: else {
! 2386: if((curl_off_t)attrs.filesize < data->state.resume_from) {
! 2387: failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T
! 2388: ") was beyond file size (%" CURL_FORMAT_CURL_OFF_T ")",
! 2389: data->state.resume_from, attrs.filesize);
! 2390: return CURLE_BAD_DOWNLOAD_RESUME;
! 2391: }
! 2392: }
! 2393: /* Now store the number of bytes we are expected to download */
! 2394: data->req.size = attrs.filesize - data->state.resume_from;
! 2395: data->req.maxdownload = attrs.filesize - data->state.resume_from;
! 2396: Curl_pgrsSetDownloadSize(data,
! 2397: attrs.filesize - data->state.resume_from);
! 2398: SFTP_SEEK(sshc->sftp_handle, data->state.resume_from);
! 2399: }
! 2400: }
! 2401:
! 2402: /* Setup the actual download */
! 2403: if(data->req.size == 0) {
! 2404: /* no data to transfer */
! 2405: Curl_setup_transfer(data, -1, -1, FALSE, -1);
! 2406: infof(data, "File already completely downloaded\n");
! 2407: state(conn, SSH_STOP);
! 2408: break;
! 2409: }
! 2410: Curl_setup_transfer(data, FIRSTSOCKET, data->req.size, FALSE, -1);
! 2411:
! 2412: /* not set by Curl_setup_transfer to preserve keepon bits */
! 2413: conn->writesockfd = conn->sockfd;
! 2414:
! 2415: /* we want to use the _receiving_ function even when the socket turns
! 2416: out writableable as the underlying libssh2 recv function will deal
! 2417: with both accordingly */
! 2418: conn->cselect_bits = CURL_CSELECT_IN;
! 2419:
! 2420: if(result) {
! 2421: /* this should never occur; the close state should be entered
! 2422: at the time the error occurs */
! 2423: state(conn, SSH_SFTP_CLOSE);
! 2424: sshc->actualcode = result;
! 2425: }
! 2426: else {
! 2427: state(conn, SSH_STOP);
! 2428: }
! 2429: break;
! 2430:
! 2431: case SSH_SFTP_CLOSE:
! 2432: if(sshc->sftp_handle) {
! 2433: rc = libssh2_sftp_close(sshc->sftp_handle);
! 2434: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2435: break;
! 2436: }
! 2437: if(rc < 0) {
! 2438: char *err_msg = NULL;
! 2439: (void)libssh2_session_last_error(sshc->ssh_session,
! 2440: &err_msg, NULL, 0);
! 2441: infof(data, "Failed to close libssh2 file: %d %s\n", rc, err_msg);
! 2442: }
! 2443: sshc->sftp_handle = NULL;
! 2444: }
! 2445:
! 2446: Curl_safefree(sftp_scp->path);
! 2447:
! 2448: DEBUGF(infof(data, "SFTP DONE done\n"));
! 2449:
! 2450: /* Check if nextstate is set and move .nextstate could be POSTQUOTE_INIT
! 2451: After nextstate is executed, the control should come back to
! 2452: SSH_SFTP_CLOSE to pass the correct result back */
! 2453: if(sshc->nextstate != SSH_NO_STATE &&
! 2454: sshc->nextstate != SSH_SFTP_CLOSE) {
! 2455: state(conn, sshc->nextstate);
! 2456: sshc->nextstate = SSH_SFTP_CLOSE;
! 2457: }
! 2458: else {
! 2459: state(conn, SSH_STOP);
! 2460: result = sshc->actualcode;
! 2461: }
! 2462: break;
! 2463:
! 2464: case SSH_SFTP_SHUTDOWN:
! 2465: /* during times we get here due to a broken transfer and then the
! 2466: sftp_handle might not have been taken down so make sure that is done
! 2467: before we proceed */
! 2468:
! 2469: if(sshc->sftp_handle) {
! 2470: rc = libssh2_sftp_close(sshc->sftp_handle);
! 2471: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2472: break;
! 2473: }
! 2474: if(rc < 0) {
! 2475: char *err_msg = NULL;
! 2476: (void)libssh2_session_last_error(sshc->ssh_session, &err_msg,
! 2477: NULL, 0);
! 2478: infof(data, "Failed to close libssh2 file: %d %s\n", rc, err_msg);
! 2479: }
! 2480: sshc->sftp_handle = NULL;
! 2481: }
! 2482: if(sshc->sftp_session) {
! 2483: rc = libssh2_sftp_shutdown(sshc->sftp_session);
! 2484: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2485: break;
! 2486: }
! 2487: if(rc < 0) {
! 2488: infof(data, "Failed to stop libssh2 sftp subsystem\n");
! 2489: }
! 2490: sshc->sftp_session = NULL;
! 2491: }
! 2492:
! 2493: Curl_safefree(sshc->homedir);
! 2494: conn->data->state.most_recent_ftp_entrypath = NULL;
! 2495:
! 2496: state(conn, SSH_SESSION_DISCONNECT);
! 2497: break;
! 2498:
! 2499: case SSH_SCP_TRANS_INIT:
! 2500: result = Curl_getworkingpath(conn, sshc->homedir, &sftp_scp->path);
! 2501: if(result) {
! 2502: sshc->actualcode = result;
! 2503: state(conn, SSH_STOP);
! 2504: break;
! 2505: }
! 2506:
! 2507: if(data->set.upload) {
! 2508: if(data->state.infilesize < 0) {
! 2509: failf(data, "SCP requires a known file size for upload");
! 2510: sshc->actualcode = CURLE_UPLOAD_FAILED;
! 2511: state(conn, SSH_SCP_CHANNEL_FREE);
! 2512: break;
! 2513: }
! 2514: state(conn, SSH_SCP_UPLOAD_INIT);
! 2515: }
! 2516: else {
! 2517: state(conn, SSH_SCP_DOWNLOAD_INIT);
! 2518: }
! 2519: break;
! 2520:
! 2521: case SSH_SCP_UPLOAD_INIT:
! 2522: /*
! 2523: * libssh2 requires that the destination path is a full path that
! 2524: * includes the destination file and name OR ends in a "/" . If this is
! 2525: * not done the destination file will be named the same name as the last
! 2526: * directory in the path.
! 2527: */
! 2528: sshc->ssh_channel =
! 2529: SCP_SEND(sshc->ssh_session, sftp_scp->path, data->set.new_file_perms,
! 2530: data->state.infilesize);
! 2531: if(!sshc->ssh_channel) {
! 2532: int ssh_err;
! 2533: char *err_msg = NULL;
! 2534:
! 2535: if(libssh2_session_last_errno(sshc->ssh_session) ==
! 2536: LIBSSH2_ERROR_EAGAIN) {
! 2537: rc = LIBSSH2_ERROR_EAGAIN;
! 2538: break;
! 2539: }
! 2540:
! 2541: ssh_err = (int)(libssh2_session_last_error(sshc->ssh_session,
! 2542: &err_msg, NULL, 0));
! 2543: failf(conn->data, "%s", err_msg);
! 2544: state(conn, SSH_SCP_CHANNEL_FREE);
! 2545: sshc->actualcode = libssh2_session_error_to_CURLE(ssh_err);
! 2546: /* Map generic errors to upload failed */
! 2547: if(sshc->actualcode == CURLE_SSH ||
! 2548: sshc->actualcode == CURLE_REMOTE_FILE_NOT_FOUND)
! 2549: sshc->actualcode = CURLE_UPLOAD_FAILED;
! 2550: break;
! 2551: }
! 2552:
! 2553: /* upload data */
! 2554: Curl_setup_transfer(data, -1, data->req.size, FALSE, FIRSTSOCKET);
! 2555:
! 2556: /* not set by Curl_setup_transfer to preserve keepon bits */
! 2557: conn->sockfd = conn->writesockfd;
! 2558:
! 2559: if(result) {
! 2560: state(conn, SSH_SCP_CHANNEL_FREE);
! 2561: sshc->actualcode = result;
! 2562: }
! 2563: else {
! 2564: /* store this original bitmask setup to use later on if we can't
! 2565: figure out a "real" bitmask */
! 2566: sshc->orig_waitfor = data->req.keepon;
! 2567:
! 2568: /* we want to use the _sending_ function even when the socket turns
! 2569: out readable as the underlying libssh2 scp send function will deal
! 2570: with both accordingly */
! 2571: conn->cselect_bits = CURL_CSELECT_OUT;
! 2572:
! 2573: state(conn, SSH_STOP);
! 2574: }
! 2575: break;
! 2576:
! 2577: case SSH_SCP_DOWNLOAD_INIT:
! 2578: {
! 2579: curl_off_t bytecount;
! 2580:
! 2581: /*
! 2582: * We must check the remote file; if it is a directory no values will
! 2583: * be set in sb
! 2584: */
! 2585:
! 2586: /*
! 2587: * If support for >2GB files exists, use it.
! 2588: */
! 2589:
! 2590: /* get a fresh new channel from the ssh layer */
! 2591: #if LIBSSH2_VERSION_NUM < 0x010700
! 2592: struct stat sb;
! 2593: memset(&sb, 0, sizeof(struct stat));
! 2594: sshc->ssh_channel = libssh2_scp_recv(sshc->ssh_session,
! 2595: sftp_scp->path, &sb);
! 2596: #else
! 2597: libssh2_struct_stat sb;
! 2598: memset(&sb, 0, sizeof(libssh2_struct_stat));
! 2599: sshc->ssh_channel = libssh2_scp_recv2(sshc->ssh_session,
! 2600: sftp_scp->path, &sb);
! 2601: #endif
! 2602:
! 2603: if(!sshc->ssh_channel) {
! 2604: int ssh_err;
! 2605: char *err_msg = NULL;
! 2606:
! 2607: if(libssh2_session_last_errno(sshc->ssh_session) ==
! 2608: LIBSSH2_ERROR_EAGAIN) {
! 2609: rc = LIBSSH2_ERROR_EAGAIN;
! 2610: break;
! 2611: }
! 2612:
! 2613:
! 2614: ssh_err = (int)(libssh2_session_last_error(sshc->ssh_session,
! 2615: &err_msg, NULL, 0));
! 2616: failf(conn->data, "%s", err_msg);
! 2617: state(conn, SSH_SCP_CHANNEL_FREE);
! 2618: sshc->actualcode = libssh2_session_error_to_CURLE(ssh_err);
! 2619: break;
! 2620: }
! 2621:
! 2622: /* download data */
! 2623: bytecount = (curl_off_t)sb.st_size;
! 2624: data->req.maxdownload = (curl_off_t)sb.st_size;
! 2625: Curl_setup_transfer(data, FIRSTSOCKET, bytecount, FALSE, -1);
! 2626:
! 2627: /* not set by Curl_setup_transfer to preserve keepon bits */
! 2628: conn->writesockfd = conn->sockfd;
! 2629:
! 2630: /* we want to use the _receiving_ function even when the socket turns
! 2631: out writableable as the underlying libssh2 recv function will deal
! 2632: with both accordingly */
! 2633: conn->cselect_bits = CURL_CSELECT_IN;
! 2634:
! 2635: if(result) {
! 2636: state(conn, SSH_SCP_CHANNEL_FREE);
! 2637: sshc->actualcode = result;
! 2638: }
! 2639: else
! 2640: state(conn, SSH_STOP);
! 2641: }
! 2642: break;
! 2643:
! 2644: case SSH_SCP_DONE:
! 2645: if(data->set.upload)
! 2646: state(conn, SSH_SCP_SEND_EOF);
! 2647: else
! 2648: state(conn, SSH_SCP_CHANNEL_FREE);
! 2649: break;
! 2650:
! 2651: case SSH_SCP_SEND_EOF:
! 2652: if(sshc->ssh_channel) {
! 2653: rc = libssh2_channel_send_eof(sshc->ssh_channel);
! 2654: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2655: break;
! 2656: }
! 2657: if(rc) {
! 2658: char *err_msg = NULL;
! 2659: (void)libssh2_session_last_error(sshc->ssh_session,
! 2660: &err_msg, NULL, 0);
! 2661: infof(data, "Failed to send libssh2 channel EOF: %d %s\n",
! 2662: rc, err_msg);
! 2663: }
! 2664: }
! 2665: state(conn, SSH_SCP_WAIT_EOF);
! 2666: break;
! 2667:
! 2668: case SSH_SCP_WAIT_EOF:
! 2669: if(sshc->ssh_channel) {
! 2670: rc = libssh2_channel_wait_eof(sshc->ssh_channel);
! 2671: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2672: break;
! 2673: }
! 2674: if(rc) {
! 2675: char *err_msg = NULL;
! 2676: (void)libssh2_session_last_error(sshc->ssh_session,
! 2677: &err_msg, NULL, 0);
! 2678: infof(data, "Failed to get channel EOF: %d %s\n", rc, err_msg);
! 2679: }
! 2680: }
! 2681: state(conn, SSH_SCP_WAIT_CLOSE);
! 2682: break;
! 2683:
! 2684: case SSH_SCP_WAIT_CLOSE:
! 2685: if(sshc->ssh_channel) {
! 2686: rc = libssh2_channel_wait_closed(sshc->ssh_channel);
! 2687: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2688: break;
! 2689: }
! 2690: if(rc) {
! 2691: char *err_msg = NULL;
! 2692: (void)libssh2_session_last_error(sshc->ssh_session,
! 2693: &err_msg, NULL, 0);
! 2694: infof(data, "Channel failed to close: %d %s\n", rc, err_msg);
! 2695: }
! 2696: }
! 2697: state(conn, SSH_SCP_CHANNEL_FREE);
! 2698: break;
! 2699:
! 2700: case SSH_SCP_CHANNEL_FREE:
! 2701: if(sshc->ssh_channel) {
! 2702: rc = libssh2_channel_free(sshc->ssh_channel);
! 2703: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2704: break;
! 2705: }
! 2706: if(rc < 0) {
! 2707: char *err_msg = NULL;
! 2708: (void)libssh2_session_last_error(sshc->ssh_session,
! 2709: &err_msg, NULL, 0);
! 2710: infof(data, "Failed to free libssh2 scp subsystem: %d %s\n",
! 2711: rc, err_msg);
! 2712: }
! 2713: sshc->ssh_channel = NULL;
! 2714: }
! 2715: DEBUGF(infof(data, "SCP DONE phase complete\n"));
! 2716: #if 0 /* PREV */
! 2717: state(conn, SSH_SESSION_DISCONNECT);
! 2718: #endif
! 2719: state(conn, SSH_STOP);
! 2720: result = sshc->actualcode;
! 2721: break;
! 2722:
! 2723: case SSH_SESSION_DISCONNECT:
! 2724: /* during weird times when we've been prematurely aborted, the channel
! 2725: is still alive when we reach this state and we MUST kill the channel
! 2726: properly first */
! 2727: if(sshc->ssh_channel) {
! 2728: rc = libssh2_channel_free(sshc->ssh_channel);
! 2729: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2730: break;
! 2731: }
! 2732: if(rc < 0) {
! 2733: char *err_msg = NULL;
! 2734: (void)libssh2_session_last_error(sshc->ssh_session,
! 2735: &err_msg, NULL, 0);
! 2736: infof(data, "Failed to free libssh2 scp subsystem: %d %s\n",
! 2737: rc, err_msg);
! 2738: }
! 2739: sshc->ssh_channel = NULL;
! 2740: }
! 2741:
! 2742: if(sshc->ssh_session) {
! 2743: rc = libssh2_session_disconnect(sshc->ssh_session, "Shutdown");
! 2744: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2745: break;
! 2746: }
! 2747: if(rc < 0) {
! 2748: char *err_msg = NULL;
! 2749: (void)libssh2_session_last_error(sshc->ssh_session,
! 2750: &err_msg, NULL, 0);
! 2751: infof(data, "Failed to disconnect libssh2 session: %d %s\n",
! 2752: rc, err_msg);
! 2753: }
! 2754: }
! 2755:
! 2756: Curl_safefree(sshc->homedir);
! 2757: conn->data->state.most_recent_ftp_entrypath = NULL;
! 2758:
! 2759: state(conn, SSH_SESSION_FREE);
! 2760: break;
! 2761:
! 2762: case SSH_SESSION_FREE:
! 2763: #ifdef HAVE_LIBSSH2_KNOWNHOST_API
! 2764: if(sshc->kh) {
! 2765: libssh2_knownhost_free(sshc->kh);
! 2766: sshc->kh = NULL;
! 2767: }
! 2768: #endif
! 2769:
! 2770: #ifdef HAVE_LIBSSH2_AGENT_API
! 2771: if(sshc->ssh_agent) {
! 2772: rc = libssh2_agent_disconnect(sshc->ssh_agent);
! 2773: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2774: break;
! 2775: }
! 2776: if(rc < 0) {
! 2777: char *err_msg = NULL;
! 2778: (void)libssh2_session_last_error(sshc->ssh_session,
! 2779: &err_msg, NULL, 0);
! 2780: infof(data, "Failed to disconnect from libssh2 agent: %d %s\n",
! 2781: rc, err_msg);
! 2782: }
! 2783: libssh2_agent_free(sshc->ssh_agent);
! 2784: sshc->ssh_agent = NULL;
! 2785:
! 2786: /* NB: there is no need to free identities, they are part of internal
! 2787: agent stuff */
! 2788: sshc->sshagent_identity = NULL;
! 2789: sshc->sshagent_prev_identity = NULL;
! 2790: }
! 2791: #endif
! 2792:
! 2793: if(sshc->ssh_session) {
! 2794: rc = libssh2_session_free(sshc->ssh_session);
! 2795: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2796: break;
! 2797: }
! 2798: if(rc < 0) {
! 2799: char *err_msg = NULL;
! 2800: (void)libssh2_session_last_error(sshc->ssh_session,
! 2801: &err_msg, NULL, 0);
! 2802: infof(data, "Failed to free libssh2 session: %d %s\n", rc, err_msg);
! 2803: }
! 2804: sshc->ssh_session = NULL;
! 2805: }
! 2806:
! 2807: /* worst-case scenario cleanup */
! 2808:
! 2809: DEBUGASSERT(sshc->ssh_session == NULL);
! 2810: DEBUGASSERT(sshc->ssh_channel == NULL);
! 2811: DEBUGASSERT(sshc->sftp_session == NULL);
! 2812: DEBUGASSERT(sshc->sftp_handle == NULL);
! 2813: #ifdef HAVE_LIBSSH2_KNOWNHOST_API
! 2814: DEBUGASSERT(sshc->kh == NULL);
! 2815: #endif
! 2816: #ifdef HAVE_LIBSSH2_AGENT_API
! 2817: DEBUGASSERT(sshc->ssh_agent == NULL);
! 2818: #endif
! 2819:
! 2820: Curl_safefree(sshc->rsa_pub);
! 2821: Curl_safefree(sshc->rsa);
! 2822:
! 2823: Curl_safefree(sshc->quote_path1);
! 2824: Curl_safefree(sshc->quote_path2);
! 2825:
! 2826: Curl_safefree(sshc->homedir);
! 2827:
! 2828: Curl_safefree(sshc->readdir_filename);
! 2829: Curl_safefree(sshc->readdir_longentry);
! 2830: Curl_safefree(sshc->readdir_line);
! 2831: Curl_safefree(sshc->readdir_linkPath);
! 2832:
! 2833: /* the code we are about to return */
! 2834: result = sshc->actualcode;
! 2835:
! 2836: memset(sshc, 0, sizeof(struct ssh_conn));
! 2837:
! 2838: connclose(conn, "SSH session free");
! 2839: sshc->state = SSH_SESSION_FREE; /* current */
! 2840: sshc->nextstate = SSH_NO_STATE;
! 2841: state(conn, SSH_STOP);
! 2842: break;
! 2843:
! 2844: case SSH_QUIT:
! 2845: /* fallthrough, just stop! */
! 2846: default:
! 2847: /* internal error */
! 2848: sshc->nextstate = SSH_NO_STATE;
! 2849: state(conn, SSH_STOP);
! 2850: break;
! 2851: }
! 2852:
! 2853: } while(!rc && (sshc->state != SSH_STOP));
! 2854:
! 2855: if(rc == LIBSSH2_ERROR_EAGAIN) {
! 2856: /* we would block, we need to wait for the socket to be ready (in the
! 2857: right direction too)! */
! 2858: *block = TRUE;
! 2859: }
! 2860:
! 2861: return result;
! 2862: }
! 2863:
! 2864: /* called by the multi interface to figure out what socket(s) to wait for and
! 2865: for what actions in the DO_DONE, PERFORM and WAITPERFORM states */
! 2866: static int ssh_perform_getsock(const struct connectdata *conn,
! 2867: curl_socket_t *sock)
! 2868: {
! 2869: #ifdef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
! 2870: int bitmap = GETSOCK_BLANK;
! 2871:
! 2872: sock[0] = conn->sock[FIRSTSOCKET];
! 2873:
! 2874: if(conn->waitfor & KEEP_RECV)
! 2875: bitmap |= GETSOCK_READSOCK(FIRSTSOCKET);
! 2876:
! 2877: if(conn->waitfor & KEEP_SEND)
! 2878: bitmap |= GETSOCK_WRITESOCK(FIRSTSOCKET);
! 2879:
! 2880: return bitmap;
! 2881: #else
! 2882: /* if we don't know the direction we can use the generic *_getsock()
! 2883: function even for the protocol_connect and doing states */
! 2884: return Curl_single_getsock(conn, sock);
! 2885: #endif
! 2886: }
! 2887:
! 2888: /* Generic function called by the multi interface to figure out what socket(s)
! 2889: to wait for and for what actions during the DOING and PROTOCONNECT states*/
! 2890: static int ssh_getsock(struct connectdata *conn,
! 2891: curl_socket_t *sock)
! 2892: {
! 2893: #ifndef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
! 2894: (void)conn;
! 2895: (void)sock;
! 2896: /* if we don't know any direction we can just play along as we used to and
! 2897: not provide any sensible info */
! 2898: return GETSOCK_BLANK;
! 2899: #else
! 2900: /* if we know the direction we can use the generic *_getsock() function even
! 2901: for the protocol_connect and doing states */
! 2902: return ssh_perform_getsock(conn, sock);
! 2903: #endif
! 2904: }
! 2905:
! 2906: #ifdef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
! 2907: /*
! 2908: * When one of the libssh2 functions has returned LIBSSH2_ERROR_EAGAIN this
! 2909: * function is used to figure out in what direction and stores this info so
! 2910: * that the multi interface can take advantage of it. Make sure to call this
! 2911: * function in all cases so that when it _doesn't_ return EAGAIN we can
! 2912: * restore the default wait bits.
! 2913: */
! 2914: static void ssh_block2waitfor(struct connectdata *conn, bool block)
! 2915: {
! 2916: struct ssh_conn *sshc = &conn->proto.sshc;
! 2917: int dir = 0;
! 2918: if(block) {
! 2919: dir = libssh2_session_block_directions(sshc->ssh_session);
! 2920: if(dir) {
! 2921: /* translate the libssh2 define bits into our own bit defines */
! 2922: conn->waitfor = ((dir&LIBSSH2_SESSION_BLOCK_INBOUND)?KEEP_RECV:0) |
! 2923: ((dir&LIBSSH2_SESSION_BLOCK_OUTBOUND)?KEEP_SEND:0);
! 2924: }
! 2925: }
! 2926: if(!dir)
! 2927: /* It didn't block or libssh2 didn't reveal in which direction, put back
! 2928: the original set */
! 2929: conn->waitfor = sshc->orig_waitfor;
! 2930: }
! 2931: #else
! 2932: /* no libssh2 directional support so we simply don't know */
! 2933: #define ssh_block2waitfor(x,y) Curl_nop_stmt
! 2934: #endif
! 2935:
! 2936: /* called repeatedly until done from multi.c */
! 2937: static CURLcode ssh_multi_statemach(struct connectdata *conn, bool *done)
! 2938: {
! 2939: struct ssh_conn *sshc = &conn->proto.sshc;
! 2940: CURLcode result = CURLE_OK;
! 2941: bool block; /* we store the status and use that to provide a ssh_getsock()
! 2942: implementation */
! 2943: do {
! 2944: result = ssh_statemach_act(conn, &block);
! 2945: *done = (sshc->state == SSH_STOP) ? TRUE : FALSE;
! 2946: /* if there's no error, it isn't done and it didn't EWOULDBLOCK, then
! 2947: try again */
! 2948: } while(!result && !*done && !block);
! 2949: ssh_block2waitfor(conn, block);
! 2950:
! 2951: return result;
! 2952: }
! 2953:
! 2954: static CURLcode ssh_block_statemach(struct connectdata *conn,
! 2955: bool disconnect)
! 2956: {
! 2957: struct ssh_conn *sshc = &conn->proto.sshc;
! 2958: CURLcode result = CURLE_OK;
! 2959: struct Curl_easy *data = conn->data;
! 2960:
! 2961: while((sshc->state != SSH_STOP) && !result) {
! 2962: bool block;
! 2963: timediff_t left = 1000;
! 2964: struct curltime now = Curl_now();
! 2965:
! 2966: result = ssh_statemach_act(conn, &block);
! 2967: if(result)
! 2968: break;
! 2969:
! 2970: if(!disconnect) {
! 2971: if(Curl_pgrsUpdate(conn))
! 2972: return CURLE_ABORTED_BY_CALLBACK;
! 2973:
! 2974: result = Curl_speedcheck(data, now);
! 2975: if(result)
! 2976: break;
! 2977:
! 2978: left = Curl_timeleft(data, NULL, FALSE);
! 2979: if(left < 0) {
! 2980: failf(data, "Operation timed out");
! 2981: return CURLE_OPERATION_TIMEDOUT;
! 2982: }
! 2983: }
! 2984:
! 2985: #ifdef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
! 2986: if(block) {
! 2987: int dir = libssh2_session_block_directions(sshc->ssh_session);
! 2988: curl_socket_t sock = conn->sock[FIRSTSOCKET];
! 2989: curl_socket_t fd_read = CURL_SOCKET_BAD;
! 2990: curl_socket_t fd_write = CURL_SOCKET_BAD;
! 2991: if(LIBSSH2_SESSION_BLOCK_INBOUND & dir)
! 2992: fd_read = sock;
! 2993: if(LIBSSH2_SESSION_BLOCK_OUTBOUND & dir)
! 2994: fd_write = sock;
! 2995: /* wait for the socket to become ready */
! 2996: (void)Curl_socket_check(fd_read, CURL_SOCKET_BAD, fd_write,
! 2997: left>1000?1000:(time_t)left);
! 2998: }
! 2999: #endif
! 3000:
! 3001: }
! 3002:
! 3003: return result;
! 3004: }
! 3005:
! 3006: /*
! 3007: * SSH setup and connection
! 3008: */
! 3009: static CURLcode ssh_setup_connection(struct connectdata *conn)
! 3010: {
! 3011: struct SSHPROTO *ssh;
! 3012:
! 3013: conn->data->req.protop = ssh = calloc(1, sizeof(struct SSHPROTO));
! 3014: if(!ssh)
! 3015: return CURLE_OUT_OF_MEMORY;
! 3016:
! 3017: return CURLE_OK;
! 3018: }
! 3019:
! 3020: static Curl_recv scp_recv, sftp_recv;
! 3021: static Curl_send scp_send, sftp_send;
! 3022:
! 3023: /*
! 3024: * Curl_ssh_connect() gets called from Curl_protocol_connect() to allow us to
! 3025: * do protocol-specific actions at connect-time.
! 3026: */
! 3027: static CURLcode ssh_connect(struct connectdata *conn, bool *done)
! 3028: {
! 3029: #ifdef CURL_LIBSSH2_DEBUG
! 3030: curl_socket_t sock;
! 3031: #endif
! 3032: struct ssh_conn *ssh;
! 3033: CURLcode result;
! 3034: struct Curl_easy *data = conn->data;
! 3035:
! 3036: /* initialize per-handle data if not already */
! 3037: if(!data->req.protop)
! 3038: ssh_setup_connection(conn);
! 3039:
! 3040: /* We default to persistent connections. We set this already in this connect
! 3041: function to make the re-use checks properly be able to check this bit. */
! 3042: connkeep(conn, "SSH default");
! 3043:
! 3044: if(conn->handler->protocol & CURLPROTO_SCP) {
! 3045: conn->recv[FIRSTSOCKET] = scp_recv;
! 3046: conn->send[FIRSTSOCKET] = scp_send;
! 3047: }
! 3048: else {
! 3049: conn->recv[FIRSTSOCKET] = sftp_recv;
! 3050: conn->send[FIRSTSOCKET] = sftp_send;
! 3051: }
! 3052: ssh = &conn->proto.sshc;
! 3053:
! 3054: #ifdef CURL_LIBSSH2_DEBUG
! 3055: if(conn->user) {
! 3056: infof(data, "User: %s\n", conn->user);
! 3057: }
! 3058: if(conn->passwd) {
! 3059: infof(data, "Password: %s\n", conn->passwd);
! 3060: }
! 3061: sock = conn->sock[FIRSTSOCKET];
! 3062: #endif /* CURL_LIBSSH2_DEBUG */
! 3063:
! 3064: ssh->ssh_session = libssh2_session_init_ex(my_libssh2_malloc,
! 3065: my_libssh2_free,
! 3066: my_libssh2_realloc, conn);
! 3067: if(ssh->ssh_session == NULL) {
! 3068: failf(data, "Failure initialising ssh session");
! 3069: return CURLE_FAILED_INIT;
! 3070: }
! 3071:
! 3072: if(data->set.ssh_compression) {
! 3073: #if LIBSSH2_VERSION_NUM >= 0x010208
! 3074: if(libssh2_session_flag(ssh->ssh_session, LIBSSH2_FLAG_COMPRESS, 1) < 0)
! 3075: #endif
! 3076: infof(data, "Failed to enable compression for ssh session\n");
! 3077: }
! 3078:
! 3079: #ifdef HAVE_LIBSSH2_KNOWNHOST_API
! 3080: if(data->set.str[STRING_SSH_KNOWNHOSTS]) {
! 3081: int rc;
! 3082: ssh->kh = libssh2_knownhost_init(ssh->ssh_session);
! 3083: if(!ssh->kh) {
! 3084: libssh2_session_free(ssh->ssh_session);
! 3085: return CURLE_FAILED_INIT;
! 3086: }
! 3087:
! 3088: /* read all known hosts from there */
! 3089: rc = libssh2_knownhost_readfile(ssh->kh,
! 3090: data->set.str[STRING_SSH_KNOWNHOSTS],
! 3091: LIBSSH2_KNOWNHOST_FILE_OPENSSH);
! 3092: if(rc < 0)
! 3093: infof(data, "Failed to read known hosts from %s\n",
! 3094: data->set.str[STRING_SSH_KNOWNHOSTS]);
! 3095: }
! 3096: #endif /* HAVE_LIBSSH2_KNOWNHOST_API */
! 3097:
! 3098: #ifdef CURL_LIBSSH2_DEBUG
! 3099: libssh2_trace(ssh->ssh_session, ~0);
! 3100: infof(data, "SSH socket: %d\n", (int)sock);
! 3101: #endif /* CURL_LIBSSH2_DEBUG */
! 3102:
! 3103: state(conn, SSH_INIT);
! 3104:
! 3105: result = ssh_multi_statemach(conn, done);
! 3106:
! 3107: return result;
! 3108: }
! 3109:
! 3110: /*
! 3111: ***********************************************************************
! 3112: *
! 3113: * scp_perform()
! 3114: *
! 3115: * This is the actual DO function for SCP. Get a file according to
! 3116: * the options previously setup.
! 3117: */
! 3118:
! 3119: static
! 3120: CURLcode scp_perform(struct connectdata *conn,
! 3121: bool *connected,
! 3122: bool *dophase_done)
! 3123: {
! 3124: CURLcode result = CURLE_OK;
! 3125:
! 3126: DEBUGF(infof(conn->data, "DO phase starts\n"));
! 3127:
! 3128: *dophase_done = FALSE; /* not done yet */
! 3129:
! 3130: /* start the first command in the DO phase */
! 3131: state(conn, SSH_SCP_TRANS_INIT);
! 3132:
! 3133: /* run the state-machine */
! 3134: result = ssh_multi_statemach(conn, dophase_done);
! 3135:
! 3136: *connected = conn->bits.tcpconnect[FIRSTSOCKET];
! 3137:
! 3138: if(*dophase_done) {
! 3139: DEBUGF(infof(conn->data, "DO phase is complete\n"));
! 3140: }
! 3141:
! 3142: return result;
! 3143: }
! 3144:
! 3145: /* called from multi.c while DOing */
! 3146: static CURLcode scp_doing(struct connectdata *conn,
! 3147: bool *dophase_done)
! 3148: {
! 3149: CURLcode result;
! 3150: result = ssh_multi_statemach(conn, dophase_done);
! 3151:
! 3152: if(*dophase_done) {
! 3153: DEBUGF(infof(conn->data, "DO phase is complete\n"));
! 3154: }
! 3155: return result;
! 3156: }
! 3157:
! 3158: /*
! 3159: * The DO function is generic for both protocols. There was previously two
! 3160: * separate ones but this way means less duplicated code.
! 3161: */
! 3162:
! 3163: static CURLcode ssh_do(struct connectdata *conn, bool *done)
! 3164: {
! 3165: CURLcode result;
! 3166: bool connected = 0;
! 3167: struct Curl_easy *data = conn->data;
! 3168: struct ssh_conn *sshc = &conn->proto.sshc;
! 3169:
! 3170: *done = FALSE; /* default to false */
! 3171:
! 3172: data->req.size = -1; /* make sure this is unknown at this point */
! 3173:
! 3174: sshc->actualcode = CURLE_OK; /* reset error code */
! 3175: sshc->secondCreateDirs = 0; /* reset the create dir attempt state
! 3176: variable */
! 3177:
! 3178: Curl_pgrsSetUploadCounter(data, 0);
! 3179: Curl_pgrsSetDownloadCounter(data, 0);
! 3180: Curl_pgrsSetUploadSize(data, -1);
! 3181: Curl_pgrsSetDownloadSize(data, -1);
! 3182:
! 3183: if(conn->handler->protocol & CURLPROTO_SCP)
! 3184: result = scp_perform(conn, &connected, done);
! 3185: else
! 3186: result = sftp_perform(conn, &connected, done);
! 3187:
! 3188: return result;
! 3189: }
! 3190:
! 3191: /* BLOCKING, but the function is using the state machine so the only reason
! 3192: this is still blocking is that the multi interface code has no support for
! 3193: disconnecting operations that takes a while */
! 3194: static CURLcode scp_disconnect(struct connectdata *conn, bool dead_connection)
! 3195: {
! 3196: CURLcode result = CURLE_OK;
! 3197: struct ssh_conn *ssh = &conn->proto.sshc;
! 3198: (void) dead_connection;
! 3199:
! 3200: if(ssh->ssh_session) {
! 3201: /* only if there's a session still around to use! */
! 3202:
! 3203: state(conn, SSH_SESSION_DISCONNECT);
! 3204:
! 3205: result = ssh_block_statemach(conn, TRUE);
! 3206: }
! 3207:
! 3208: return result;
! 3209: }
! 3210:
! 3211: /* generic done function for both SCP and SFTP called from their specific
! 3212: done functions */
! 3213: static CURLcode ssh_done(struct connectdata *conn, CURLcode status)
! 3214: {
! 3215: CURLcode result = CURLE_OK;
! 3216: struct SSHPROTO *sftp_scp = conn->data->req.protop;
! 3217:
! 3218: if(!status) {
! 3219: /* run the state-machine */
! 3220: result = ssh_block_statemach(conn, FALSE);
! 3221: }
! 3222: else
! 3223: result = status;
! 3224:
! 3225: if(sftp_scp)
! 3226: Curl_safefree(sftp_scp->path);
! 3227: if(Curl_pgrsDone(conn))
! 3228: return CURLE_ABORTED_BY_CALLBACK;
! 3229:
! 3230: conn->data->req.keepon = 0; /* clear all bits */
! 3231: return result;
! 3232: }
! 3233:
! 3234:
! 3235: static CURLcode scp_done(struct connectdata *conn, CURLcode status,
! 3236: bool premature)
! 3237: {
! 3238: (void)premature; /* not used */
! 3239:
! 3240: if(!status)
! 3241: state(conn, SSH_SCP_DONE);
! 3242:
! 3243: return ssh_done(conn, status);
! 3244:
! 3245: }
! 3246:
! 3247: static ssize_t scp_send(struct connectdata *conn, int sockindex,
! 3248: const void *mem, size_t len, CURLcode *err)
! 3249: {
! 3250: ssize_t nwrite;
! 3251: (void)sockindex; /* we only support SCP on the fixed known primary socket */
! 3252:
! 3253: /* libssh2_channel_write() returns int! */
! 3254: nwrite = (ssize_t)
! 3255: libssh2_channel_write(conn->proto.sshc.ssh_channel, mem, len);
! 3256:
! 3257: ssh_block2waitfor(conn, (nwrite == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
! 3258:
! 3259: if(nwrite == LIBSSH2_ERROR_EAGAIN) {
! 3260: *err = CURLE_AGAIN;
! 3261: nwrite = 0;
! 3262: }
! 3263: else if(nwrite < LIBSSH2_ERROR_NONE) {
! 3264: *err = libssh2_session_error_to_CURLE((int)nwrite);
! 3265: nwrite = -1;
! 3266: }
! 3267:
! 3268: return nwrite;
! 3269: }
! 3270:
! 3271: static ssize_t scp_recv(struct connectdata *conn, int sockindex,
! 3272: char *mem, size_t len, CURLcode *err)
! 3273: {
! 3274: ssize_t nread;
! 3275: (void)sockindex; /* we only support SCP on the fixed known primary socket */
! 3276:
! 3277: /* libssh2_channel_read() returns int */
! 3278: nread = (ssize_t)
! 3279: libssh2_channel_read(conn->proto.sshc.ssh_channel, mem, len);
! 3280:
! 3281: ssh_block2waitfor(conn, (nread == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
! 3282: if(nread == LIBSSH2_ERROR_EAGAIN) {
! 3283: *err = CURLE_AGAIN;
! 3284: nread = -1;
! 3285: }
! 3286:
! 3287: return nread;
! 3288: }
! 3289:
! 3290: /*
! 3291: * =============== SFTP ===============
! 3292: */
! 3293:
! 3294: /*
! 3295: ***********************************************************************
! 3296: *
! 3297: * sftp_perform()
! 3298: *
! 3299: * This is the actual DO function for SFTP. Get a file/directory according to
! 3300: * the options previously setup.
! 3301: */
! 3302:
! 3303: static
! 3304: CURLcode sftp_perform(struct connectdata *conn,
! 3305: bool *connected,
! 3306: bool *dophase_done)
! 3307: {
! 3308: CURLcode result = CURLE_OK;
! 3309:
! 3310: DEBUGF(infof(conn->data, "DO phase starts\n"));
! 3311:
! 3312: *dophase_done = FALSE; /* not done yet */
! 3313:
! 3314: /* start the first command in the DO phase */
! 3315: state(conn, SSH_SFTP_QUOTE_INIT);
! 3316:
! 3317: /* run the state-machine */
! 3318: result = ssh_multi_statemach(conn, dophase_done);
! 3319:
! 3320: *connected = conn->bits.tcpconnect[FIRSTSOCKET];
! 3321:
! 3322: if(*dophase_done) {
! 3323: DEBUGF(infof(conn->data, "DO phase is complete\n"));
! 3324: }
! 3325:
! 3326: return result;
! 3327: }
! 3328:
! 3329: /* called from multi.c while DOing */
! 3330: static CURLcode sftp_doing(struct connectdata *conn,
! 3331: bool *dophase_done)
! 3332: {
! 3333: CURLcode result = ssh_multi_statemach(conn, dophase_done);
! 3334:
! 3335: if(*dophase_done) {
! 3336: DEBUGF(infof(conn->data, "DO phase is complete\n"));
! 3337: }
! 3338: return result;
! 3339: }
! 3340:
! 3341: /* BLOCKING, but the function is using the state machine so the only reason
! 3342: this is still blocking is that the multi interface code has no support for
! 3343: disconnecting operations that takes a while */
! 3344: static CURLcode sftp_disconnect(struct connectdata *conn, bool dead_connection)
! 3345: {
! 3346: CURLcode result = CURLE_OK;
! 3347: (void) dead_connection;
! 3348:
! 3349: DEBUGF(infof(conn->data, "SSH DISCONNECT starts now\n"));
! 3350:
! 3351: if(conn->proto.sshc.ssh_session) {
! 3352: /* only if there's a session still around to use! */
! 3353: state(conn, SSH_SFTP_SHUTDOWN);
! 3354: result = ssh_block_statemach(conn, TRUE);
! 3355: }
! 3356:
! 3357: DEBUGF(infof(conn->data, "SSH DISCONNECT is done\n"));
! 3358:
! 3359: return result;
! 3360:
! 3361: }
! 3362:
! 3363: static CURLcode sftp_done(struct connectdata *conn, CURLcode status,
! 3364: bool premature)
! 3365: {
! 3366: struct ssh_conn *sshc = &conn->proto.sshc;
! 3367:
! 3368: if(!status) {
! 3369: /* Post quote commands are executed after the SFTP_CLOSE state to avoid
! 3370: errors that could happen due to open file handles during POSTQUOTE
! 3371: operation */
! 3372: if(!premature && conn->data->set.postquote && !conn->bits.retry)
! 3373: sshc->nextstate = SSH_SFTP_POSTQUOTE_INIT;
! 3374: state(conn, SSH_SFTP_CLOSE);
! 3375: }
! 3376: return ssh_done(conn, status);
! 3377: }
! 3378:
! 3379: /* return number of sent bytes */
! 3380: static ssize_t sftp_send(struct connectdata *conn, int sockindex,
! 3381: const void *mem, size_t len, CURLcode *err)
! 3382: {
! 3383: ssize_t nwrite; /* libssh2_sftp_write() used to return size_t in 0.14
! 3384: but is changed to ssize_t in 0.15. These days we don't
! 3385: support libssh2 0.15*/
! 3386: (void)sockindex;
! 3387:
! 3388: nwrite = libssh2_sftp_write(conn->proto.sshc.sftp_handle, mem, len);
! 3389:
! 3390: ssh_block2waitfor(conn, (nwrite == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
! 3391:
! 3392: if(nwrite == LIBSSH2_ERROR_EAGAIN) {
! 3393: *err = CURLE_AGAIN;
! 3394: nwrite = 0;
! 3395: }
! 3396: else if(nwrite < LIBSSH2_ERROR_NONE) {
! 3397: *err = libssh2_session_error_to_CURLE((int)nwrite);
! 3398: nwrite = -1;
! 3399: }
! 3400:
! 3401: return nwrite;
! 3402: }
! 3403:
! 3404: /*
! 3405: * Return number of received (decrypted) bytes
! 3406: * or <0 on error
! 3407: */
! 3408: static ssize_t sftp_recv(struct connectdata *conn, int sockindex,
! 3409: char *mem, size_t len, CURLcode *err)
! 3410: {
! 3411: ssize_t nread;
! 3412: (void)sockindex;
! 3413:
! 3414: nread = libssh2_sftp_read(conn->proto.sshc.sftp_handle, mem, len);
! 3415:
! 3416: ssh_block2waitfor(conn, (nread == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
! 3417:
! 3418: if(nread == LIBSSH2_ERROR_EAGAIN) {
! 3419: *err = CURLE_AGAIN;
! 3420: nread = -1;
! 3421:
! 3422: }
! 3423: else if(nread < 0) {
! 3424: *err = libssh2_session_error_to_CURLE((int)nread);
! 3425: }
! 3426: return nread;
! 3427: }
! 3428:
! 3429: static const char *sftp_libssh2_strerror(int err)
! 3430: {
! 3431: switch(err) {
! 3432: case LIBSSH2_FX_NO_SUCH_FILE:
! 3433: return "No such file or directory";
! 3434:
! 3435: case LIBSSH2_FX_PERMISSION_DENIED:
! 3436: return "Permission denied";
! 3437:
! 3438: case LIBSSH2_FX_FAILURE:
! 3439: return "Operation failed";
! 3440:
! 3441: case LIBSSH2_FX_BAD_MESSAGE:
! 3442: return "Bad message from SFTP server";
! 3443:
! 3444: case LIBSSH2_FX_NO_CONNECTION:
! 3445: return "Not connected to SFTP server";
! 3446:
! 3447: case LIBSSH2_FX_CONNECTION_LOST:
! 3448: return "Connection to SFTP server lost";
! 3449:
! 3450: case LIBSSH2_FX_OP_UNSUPPORTED:
! 3451: return "Operation not supported by SFTP server";
! 3452:
! 3453: case LIBSSH2_FX_INVALID_HANDLE:
! 3454: return "Invalid handle";
! 3455:
! 3456: case LIBSSH2_FX_NO_SUCH_PATH:
! 3457: return "No such file or directory";
! 3458:
! 3459: case LIBSSH2_FX_FILE_ALREADY_EXISTS:
! 3460: return "File already exists";
! 3461:
! 3462: case LIBSSH2_FX_WRITE_PROTECT:
! 3463: return "File is write protected";
! 3464:
! 3465: case LIBSSH2_FX_NO_MEDIA:
! 3466: return "No media";
! 3467:
! 3468: case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:
! 3469: return "Disk full";
! 3470:
! 3471: case LIBSSH2_FX_QUOTA_EXCEEDED:
! 3472: return "User quota exceeded";
! 3473:
! 3474: case LIBSSH2_FX_UNKNOWN_PRINCIPLE:
! 3475: return "Unknown principle";
! 3476:
! 3477: case LIBSSH2_FX_LOCK_CONFlICT:
! 3478: return "File lock conflict";
! 3479:
! 3480: case LIBSSH2_FX_DIR_NOT_EMPTY:
! 3481: return "Directory not empty";
! 3482:
! 3483: case LIBSSH2_FX_NOT_A_DIRECTORY:
! 3484: return "Not a directory";
! 3485:
! 3486: case LIBSSH2_FX_INVALID_FILENAME:
! 3487: return "Invalid filename";
! 3488:
! 3489: case LIBSSH2_FX_LINK_LOOP:
! 3490: return "Link points to itself";
! 3491: }
! 3492: return "Unknown error in libssh2";
! 3493: }
! 3494:
! 3495: CURLcode Curl_ssh_init(void)
! 3496: {
! 3497: #ifdef HAVE_LIBSSH2_INIT
! 3498: if(libssh2_init(0)) {
! 3499: DEBUGF(fprintf(stderr, "Error: libssh2_init failed\n"));
! 3500: return CURLE_FAILED_INIT;
! 3501: }
! 3502: #endif
! 3503: return CURLE_OK;
! 3504: }
! 3505:
! 3506: void Curl_ssh_cleanup(void)
! 3507: {
! 3508: #ifdef HAVE_LIBSSH2_EXIT
! 3509: (void)libssh2_exit();
! 3510: #endif
! 3511: }
! 3512:
! 3513: size_t Curl_ssh_version(char *buffer, size_t buflen)
! 3514: {
! 3515: return msnprintf(buffer, buflen, "libssh2/%s", LIBSSH2_VERSION);
! 3516: }
! 3517:
! 3518: #endif /* USE_LIBSSH2 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to libssh2.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib / vssh