Lines Matching refs:data
103 static CURLcode ssh_force_knownhost_key_type(struct Curl_easy *data);
104 static CURLcode ssh_connect(struct Curl_easy *data, bool *done);
105 static CURLcode ssh_multi_statemach(struct Curl_easy *data, bool *done);
106 static CURLcode ssh_do(struct Curl_easy *data, bool *done);
107 static CURLcode scp_done(struct Curl_easy *data, CURLcode c, bool premature);
108 static CURLcode scp_doing(struct Curl_easy *data, bool *dophase_done);
109 static CURLcode scp_disconnect(struct Curl_easy *data,
111 static CURLcode sftp_done(struct Curl_easy *data, CURLcode, bool premature);
112 static CURLcode sftp_doing(struct Curl_easy *data, bool *dophase_done);
113 static CURLcode sftp_disconnect(struct Curl_easy *data,
115 static CURLcode sftp_perform(struct Curl_easy *data, bool *connected,
117 static int ssh_getsock(struct Curl_easy *data, struct connectdata *conn,
119 static CURLcode ssh_setup_connection(struct Curl_easy *data,
121 static void ssh_attach(struct Curl_easy *data, struct connectdata *conn);
187 struct Curl_easy *data = (struct Curl_easy *)*abstract;
202 struct connectdata *conn = data->conn;
305 static void state(struct Curl_easy *data, sshstate nowstate)
307 struct connectdata *conn = data->conn;
378 infof(data, "SFTP %p state change from %s to %s",
467 static CURLcode ssh_knownhost(struct Curl_easy *data)
475 if(data->set.str[STRING_SSH_KNOWNHOSTS]) {
477 struct connectdata *conn = data->conn;
493 data->set.ssh_keyfunc ? data->set.ssh_keyfunc : sshkeycallback;
526 infof(data, "unsupported key type, can't check knownhosts");
554 infof(data, "SSH host check: %d, key: %s", keycheck,
579 Curl_set_in_callback(data, true);
580 rc = func(data, knownkeyp, /* from the knownhosts file */
582 keymatch, data->set.ssh_keyfunc_userp);
583 Curl_set_in_callback(data, false);
593 state(data, SSH_SESSION_FREE);
617 infof(data, "WARNING: adding the known host %s failed",
625 data->set.str[STRING_SSH_KNOWNHOSTS],
628 infof(data, "WARNING: writing %s failed",
629 data->set.str[STRING_SSH_KNOWNHOSTS]);
637 (void)data;
642 static CURLcode ssh_check_fingerprint(struct Curl_easy *data)
644 struct connectdata *conn = data->conn;
646 const char *pubkey_md5 = data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5];
647 const char *pubkey_sha256 = data->set.str[STRING_SSH_HOST_PUBLIC_KEY_SHA256];
649 infof(data, "SSH MD5 public key: %s",
651 infof(data, "SSH SHA256 public key: %s",
678 failf(data,
681 state(data, SSH_SESSION_FREE);
690 state(data, SSH_SESSION_FREE);
696 failf(data, "sha256 fingerprint could not be encoded");
697 state(data, SSH_SESSION_FREE);
702 infof(data, "SSH SHA256 fingerprint: %s", fingerprint_b64);
720 failf(data,
724 state(data, SSH_SESSION_FREE);
731 infof(data, "SHA256 checksum match");
748 infof(data, "SSH MD5 fingerprint: %s", md5buffer);
755 failf(data,
760 failf(data,
764 state(data, SSH_SESSION_FREE);
768 infof(data, "MD5 checksum match");
772 if(data->set.ssh_hostkeyfunc) {
781 Curl_set_in_callback(data, true);
782 rc = data->set.ssh_hostkeyfunc(data->set.ssh_hostkeyfunc_userp,
784 Curl_set_in_callback(data, false);
786 state(data, SSH_SESSION_FREE);
792 state(data, SSH_SESSION_FREE);
799 return ssh_knownhost(data);
812 static CURLcode ssh_force_knownhost_key_type(struct Curl_easy *data)
842 struct connectdata *conn = data->conn;
850 if(sshc->kh && !data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5]) {
860 infof(data, "Invalid host pattern %s in %s",
861 store->name, data->set.str[STRING_SSH_KNOWNHOSTS]);
888 infof(data, "Found host %s in %s",
889 conn->host.name, data->set.str[STRING_SSH_KNOWNHOSTS]);
928 failf(data, "Found host key type RSA1 which is not supported");
931 failf(data, "Unknown host key type: %i",
936 infof(data, "Set \"%s\" as SSH hostkey type", hostkey_method);
943 failf(data, "libssh2: %s", errmsg);
948 infof(data, "Did not find host %s in %s",
949 conn->host.name, data->set.str[STRING_SSH_KNOWNHOSTS]);
960 * blocking and without reaching the end. The data the pointer 'block' points
965 static CURLcode ssh_statemach_act(struct Curl_easy *data, bool *block)
968 struct connectdata *conn = data->conn;
969 struct SSHPROTO *sshp = data->req.p.ssh;
990 result = ssh_force_knownhost_key_type(data);
992 state(data, SSH_SESSION_FREE);
997 state(data, SSH_S_STARTUP);
1008 failf(data, "Failure establishing ssh session: %d, %s", rc, err_msg);
1010 state(data, SSH_SESSION_FREE);
1015 state(data, SSH_HOSTKEY);
1024 result = ssh_check_fingerprint(data);
1026 state(data, SSH_AUTHLIST);
1048 infof(data, "SSH user accepted with no authentication");
1049 state(data, SSH_AUTH_DONE);
1056 state(data, SSH_SESSION_FREE);
1061 infof(data, "SSH authentication methods available: %s",
1064 state(data, SSH_AUTH_PKEY_INIT);
1074 if((data->set.ssh_auth_types & CURLSSH_AUTH_PUBLICKEY) &&
1080 if(data->set.str[STRING_SSH_PRIVATE_KEY])
1081 sshc->rsa = strdup(data->set.str[STRING_SSH_PRIVATE_KEY]);
1125 if(data->set.str[STRING_SSH_PUBLIC_KEY]
1127 && data->set.str[STRING_SSH_PUBLIC_KEY][0]) {
1128 sshc->rsa_pub = strdup(data->set.str[STRING_SSH_PUBLIC_KEY]);
1136 state(data, SSH_SESSION_FREE);
1141 sshc->passphrase = data->set.ssl.key_passwd;
1146 infof(data, "Using SSH public key file '%s'", sshc->rsa_pub);
1147 infof(data, "Using SSH private key file '%s'", sshc->rsa);
1149 state(data, SSH_AUTH_PKEY);
1152 state(data, SSH_AUTH_PASS_INIT);
1174 infof(data, "Initialized SSH public key authentication");
1175 state(data, SSH_AUTH_DONE);
1189 infof(data, "SSH public key authentication failed: %s", err_msg);
1190 state(data, SSH_AUTH_PASS_INIT);
1196 if((data->set.ssh_auth_types & CURLSSH_AUTH_PASSWORD) &&
1198 state(data, SSH_AUTH_PASS);
1201 state(data, SSH_AUTH_HOST_INIT);
1217 infof(data, "Initialized password authentication");
1218 state(data, SSH_AUTH_DONE);
1221 state(data, SSH_AUTH_HOST_INIT);
1227 if((data->set.ssh_auth_types & CURLSSH_AUTH_HOST) &&
1229 state(data, SSH_AUTH_HOST);
1232 state(data, SSH_AUTH_AGENT_INIT);
1237 state(data, SSH_AUTH_AGENT_INIT);
1242 if((data->set.ssh_auth_types & CURLSSH_AUTH_AGENT)
1251 infof(data, "Could not create agent object");
1253 state(data, SSH_AUTH_KEY_INIT);
1262 infof(data, "Failure connecting to agent");
1263 state(data, SSH_AUTH_KEY_INIT);
1267 state(data, SSH_AUTH_AGENT_LIST);
1272 state(data, SSH_AUTH_KEY_INIT);
1282 infof(data, "Failure requesting identities to agent");
1283 state(data, SSH_AUTH_KEY_INIT);
1287 state(data, SSH_AUTH_AGENT);
1318 infof(data, "Failure requesting identities to agent");
1320 infof(data, "No identity would match");
1324 infof(data, "Agent based authentication successful");
1325 state(data, SSH_AUTH_DONE);
1328 state(data, SSH_AUTH_KEY_INIT);
1335 if((data->set.ssh_auth_types & CURLSSH_AUTH_KEYBOARD)
1337 state(data, SSH_AUTH_KEY);
1340 state(data, SSH_AUTH_DONE);
1356 infof(data, "Initialized keyboard interactive authentication");
1358 state(data, SSH_AUTH_DONE);
1363 failf(data, "Authentication failure");
1364 state(data, SSH_SESSION_FREE);
1372 infof(data, "Authentication complete");
1374 Curl_pgrsTime(data, TIMER_APPCONNECT); /* SSH is connected */
1380 state(data, SSH_SFTP_INIT);
1383 infof(data, "SSH CONNECT phase done");
1384 state(data, SSH_STOP);
1402 failf(data, "Failure initializing sftp session: %s", err_msg);
1403 state(data, SSH_SESSION_FREE);
1407 state(data, SSH_SFTP_REALPATH);
1427 state(data, SSH_SFTP_CLOSE);
1431 data->state.most_recent_ftp_entrypath = sshc->homedir;
1443 DEBUGF(infof(data, "error = %lu makes libcurl = %d",
1445 state(data, SSH_STOP);
1453 DEBUGF(infof(data, "SSH CONNECT phase done"));
1454 state(data, SSH_STOP);
1459 result = Curl_getworkingpath(data, sshc->homedir, &sshp->path);
1462 state(data, SSH_STOP);
1466 if(data->set.quote) {
1467 infof(data, "Sending quote commands");
1468 sshc->quote_item = data->set.quote;
1469 state(data, SSH_SFTP_QUOTE);
1472 state(data, SSH_SFTP_GETINFO);
1477 if(data->set.postquote) {
1478 infof(data, "Sending quote commands");
1479 sshc->quote_item = data->set.postquote;
1480 state(data, SSH_SFTP_QUOTE);
1483 state(data, SSH_STOP);
1498 char *cmd = sshc->quote_item->data;
1517 state(data, SSH_SFTP_CLOSE);
1521 Curl_debug(data, CURLINFO_HEADER_OUT, (char *)"PWD\n", 4);
1522 Curl_debug(data, CURLINFO_HEADER_IN, tmp, strlen(tmp));
1527 result = Curl_client_write(data, CLIENTWRITE_HEADER, tmp, strlen(tmp));
1530 state(data, SSH_SFTP_CLOSE);
1535 state(data, SSH_SFTP_NEXT_QUOTE);
1545 failf(data, "Syntax error command '%s', missing parameter",
1547 state(data, SSH_SFTP_CLOSE);
1560 failf(data, "Out of memory");
1562 failf(data, "Syntax error: Bad first parameter to '%s'", cmd);
1563 state(data, SSH_SFTP_CLOSE);
1587 failf(data, "Out of memory");
1589 failf(data, "Syntax error in %s: Bad second parameter", cmd);
1591 state(data, SSH_SFTP_CLOSE);
1597 state(data, SSH_SFTP_QUOTE_STAT);
1608 failf(data, "Out of memory");
1610 failf(data,
1613 state(data, SSH_SFTP_CLOSE);
1618 state(data, SSH_SFTP_QUOTE_SYMLINK);
1623 state(data, SSH_SFTP_QUOTE_MKDIR);
1633 failf(data, "Out of memory");
1635 failf(data, "Syntax error in rename: Bad second parameter");
1637 state(data, SSH_SFTP_CLOSE);
1642 state(data, SSH_SFTP_QUOTE_RENAME);
1647 state(data, SSH_SFTP_QUOTE_RMDIR);
1651 state(data, SSH_SFTP_QUOTE_UNLINK);
1656 state(data, SSH_SFTP_QUOTE_STATVFS);
1661 failf(data, "Unknown SFTP command");
1664 state(data, SSH_SFTP_CLOSE);
1677 state(data, SSH_SFTP_QUOTE);
1681 state(data, sshc->nextstate);
1685 state(data, SSH_SFTP_GETINFO);
1692 char *cmd = sshc->quote_item->data;
1721 failf(data, "Attempt to get SFTP stats failed: %s",
1723 state(data, SSH_SFTP_CLOSE);
1738 failf(data, "Syntax error: chgrp gid not a number");
1739 state(data, SSH_SFTP_CLOSE);
1753 failf(data, "Syntax error: chmod permissions not a number");
1754 state(data, SSH_SFTP_CLOSE);
1767 failf(data, "Syntax error: chown uid not a number");
1768 state(data, SSH_SFTP_CLOSE);
1780 failf(data, "incorrect date format for %.*s", 5, cmd);
1786 failf(data, "date overflow");
1793 state(data, SSH_SFTP_CLOSE);
1807 state(data, SSH_SFTP_QUOTE_SETSTAT);
1823 failf(data, "Attempt to set SFTP stats failed: %s",
1825 state(data, SSH_SFTP_CLOSE);
1830 state(data, SSH_SFTP_NEXT_QUOTE);
1846 failf(data, "symlink command failed: %s",
1848 state(data, SSH_SFTP_CLOSE);
1853 state(data, SSH_SFTP_NEXT_QUOTE);
1859 data->set.new_directory_perms);
1866 failf(data, "mkdir command failed: %s",
1868 state(data, SSH_SFTP_CLOSE);
1873 state(data, SSH_SFTP_NEXT_QUOTE);
1892 failf(data, "rename command failed: %s",
1894 state(data, SSH_SFTP_CLOSE);
1899 state(data, SSH_SFTP_NEXT_QUOTE);
1911 failf(data, "rmdir command failed: %s",
1913 state(data, SSH_SFTP_CLOSE);
1918 state(data, SSH_SFTP_NEXT_QUOTE);
1930 failf(data, "rm command failed: %s", sftp_libssh2_strerror(sftperr));
1931 state(data, SSH_SFTP_CLOSE);
1936 state(data, SSH_SFTP_NEXT_QUOTE);
1953 failf(data, "statvfs command failed: %s",
1955 state(data, SSH_SFTP_CLOSE);
1986 state(data, SSH_SFTP_CLOSE);
1991 result = Curl_client_write(data, CLIENTWRITE_HEADER, tmp, strlen(tmp));
1994 state(data, SSH_SFTP_CLOSE);
1999 state(data, SSH_SFTP_NEXT_QUOTE);
2005 if(data->set.get_filetime) {
2006 state(data, SSH_SFTP_FILETIME);
2009 state(data, SSH_SFTP_TRANS_INIT);
2025 data->info.filetime = attrs.mtime;
2028 state(data, SSH_SFTP_TRANS_INIT);
2033 if(data->state.upload)
2034 state(data, SSH_SFTP_UPLOAD_INIT);
2037 state(data, SSH_SFTP_READDIR_INIT);
2039 state(data, SSH_SFTP_DOWNLOAD_INIT);
2053 if(data->state.resume_from) {
2055 if(data->state.resume_from < 0) {
2063 data->state.resume_from = 0;
2068 failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size);
2071 data->state.resume_from = attrs.filesize;
2076 if(data->set.remote_append)
2079 else if(data->state.resume_from > 0)
2089 flags, data->set.new_file_perms,
2106 state(data, SSH_SFTP_CLOSE);
2109 failf(data, "Creating the dir/file failed: %s",
2116 (data->set.ftp_create_missing_dirs &&
2121 state(data, SSH_SFTP_CREATE_DIRS_INIT);
2124 state(data, SSH_SFTP_CLOSE);
2134 failf(data, "Upload failed: %s (%lu/%d)",
2143 if(data->state.resume_from > 0) {
2146 Curl_set_in_callback(data, true);
2147 seekerr = conn->seek_func(conn->seek_client, data->state.resume_from,
2149 Curl_set_in_callback(data, false);
2156 failf(data, "Could not seek stream");
2163 (data->state.resume_from - passed >
2165 sizeof(scratch) : curlx_sotouz(data->state.resume_from - passed);
2168 Curl_set_in_callback(data, true);
2169 actuallyread = data->state.fread_func(scratch, 1,
2171 data->state.in);
2172 Curl_set_in_callback(data, false);
2178 failf(data, "Failed to read data");
2181 } while(passed < data->state.resume_from);
2185 if(data->state.infilesize > 0) {
2186 data->state.infilesize -= data->state.resume_from;
2187 data->req.size = data->state.infilesize;
2188 Curl_pgrsSetUploadSize(data, data->state.infilesize);
2191 SFTP_SEEK(sshc->sftp_handle, data->state.resume_from);
2193 if(data->state.infilesize > 0) {
2194 data->req.size = data->state.infilesize;
2195 Curl_pgrsSetUploadSize(data, data->state.infilesize);
2197 /* upload data */
2198 Curl_setup_transfer(data, -1, -1, FALSE, FIRSTSOCKET);
2204 state(data, SSH_SFTP_CLOSE);
2210 sshc->orig_waitfor = data->req.keepon;
2215 data->state.select_bits = CURL_CSELECT_OUT;
2220 Curl_expire(data, 0, EXPIRE_RUN_NOW);
2222 state(data, SSH_STOP);
2230 state(data, SSH_SFTP_CREATE_DIRS);
2233 state(data, SSH_SFTP_UPLOAD_INIT);
2242 infof(data, "Creating directory '%s'", sshp->path);
2243 state(data, SSH_SFTP_CREATE_DIRS_MKDIR);
2246 state(data, SSH_SFTP_UPLOAD_INIT);
2253 data->set.new_directory_perms);
2270 state(data, SSH_SFTP_CLOSE);
2276 state(data, SSH_SFTP_CREATE_DIRS);
2280 Curl_pgrsSetDownloadSize(data, -1);
2281 if(data->req.no_body) {
2282 state(data, SSH_STOP);
2302 failf(data, "Could not open directory for reading: %s",
2304 state(data, SSH_SFTP_CLOSE);
2311 state(data, SSH_SFTP_CLOSE);
2318 state(data, SSH_SFTP_CLOSE);
2323 state(data, SSH_SFTP_READDIR);
2340 if(data->set.list_only) {
2341 result = Curl_client_write(data, CLIENTWRITE_BODY,
2345 result = Curl_client_write(data, CLIENTWRITE_BODY,
2348 state(data, SSH_STOP);
2363 state(data, SSH_SFTP_READDIR_LINK);
2368 state(data, SSH_SFTP_READDIR_BOTTOM);
2373 state(data, SSH_SFTP_CLOSE);
2380 state(data, SSH_SFTP_READDIR_DONE);
2387 failf(data, "Could not open remote file for reading: %s :: %d",
2392 state(data, SSH_SFTP_CLOSE);
2415 state(data, SSH_SFTP_CLOSE);
2420 state(data, SSH_SFTP_READDIR_BOTTOM);
2426 result = Curl_client_write(data, CLIENTWRITE_BODY,
2432 state(data, SSH_STOP);
2436 state(data, SSH_SFTP_READDIR);
2450 /* no data to transfer */
2451 Curl_setup_transfer(data, -1, -1, FALSE, -1);
2452 state(data, SSH_STOP);
2462 LIBSSH2_FXF_READ, data->set.new_file_perms,
2471 failf(data, "Could not open remote file for reading: %s",
2473 state(data, SSH_SFTP_CLOSE);
2478 state(data, SSH_SFTP_DOWNLOAD_STAT);
2500 data->req.size = -1;
2501 data->req.maxdownload = -1;
2502 Curl_pgrsSetDownloadSize(data, -1);
2508 failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size);
2511 if(data->state.use_range) {
2518 from_t = curlx_strtoofft(data->state.range, &ptr, 10, &from);
2536 failf(data, "Offset (%"
2552 data->req.size = size;
2553 data->req.maxdownload = size;
2554 Curl_pgrsSetDownloadSize(data, size);
2558 if(data->state.resume_from) {
2559 if(data->state.resume_from < 0) {
2561 if((curl_off_t)attrs.filesize < -data->state.resume_from) {
2562 failf(data, "Offset (%"
2565 data->state.resume_from, (curl_off_t)attrs.filesize);
2569 data->state.resume_from += attrs.filesize;
2572 if((curl_off_t)attrs.filesize < data->state.resume_from) {
2573 failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T
2575 data->state.resume_from, (curl_off_t)attrs.filesize);
2580 data->req.size = attrs.filesize - data->state.resume_from;
2581 data->req.maxdownload = attrs.filesize - data->state.resume_from;
2582 Curl_pgrsSetDownloadSize(data,
2583 attrs.filesize - data->state.resume_from);
2584 SFTP_SEEK(sshc->sftp_handle, data->state.resume_from);
2589 if(data->req.size == 0) {
2590 /* no data to transfer */
2591 Curl_setup_transfer(data, -1, -1, FALSE, -1);
2592 infof(data, "File already completely downloaded");
2593 state(data, SSH_STOP);
2596 Curl_setup_transfer(data, FIRSTSOCKET, data->req.size, FALSE, -1);
2604 data->state.select_bits = CURL_CSELECT_IN;
2609 state(data, SSH_SFTP_CLOSE);
2613 state(data, SSH_STOP);
2627 infof(data, "Failed to close libssh2 file: %d %s", rc, err_msg);
2634 DEBUGF(infof(data, "SFTP DONE done"));
2641 state(data, sshc->nextstate);
2645 state(data, SSH_STOP);
2664 infof(data, "Failed to close libssh2 file: %d %s", rc, err_msg);
2674 infof(data, "Failed to stop libssh2 sftp subsystem");
2680 data->state.most_recent_ftp_entrypath = NULL;
2682 state(data, SSH_SESSION_DISCONNECT);
2686 result = Curl_getworkingpath(data, sshc->homedir, &sshp->path);
2689 state(data, SSH_STOP);
2693 if(data->state.upload) {
2694 if(data->state.infilesize < 0) {
2695 failf(data, "SCP requires a known file size for upload");
2697 state(data, SSH_SCP_CHANNEL_FREE);
2700 state(data, SSH_SCP_UPLOAD_INIT);
2703 state(data, SSH_SCP_DOWNLOAD_INIT);
2715 SCP_SEND(sshc->ssh_session, sshp->path, data->set.new_file_perms,
2716 data->state.infilesize);
2729 failf(data, "%s", err_msg);
2730 state(data, SSH_SCP_CHANNEL_FREE);
2739 /* upload data */
2740 data->req.size = data->state.infilesize;
2741 Curl_pgrsSetUploadSize(data, data->state.infilesize);
2742 Curl_setup_transfer(data, -1, -1, FALSE, FIRSTSOCKET);
2748 state(data, SSH_SCP_CHANNEL_FREE);
2754 sshc->orig_waitfor = data->req.keepon;
2759 data->state.select_bits = CURL_CSELECT_OUT;
2761 state(data, SSH_STOP);
2804 failf(data, "%s", err_msg);
2805 state(data, SSH_SCP_CHANNEL_FREE);
2810 /* download data */
2812 data->req.maxdownload = (curl_off_t)sb.st_size;
2813 Curl_setup_transfer(data, FIRSTSOCKET, bytecount, FALSE, -1);
2821 data->state.select_bits = CURL_CSELECT_IN;
2824 state(data, SSH_SCP_CHANNEL_FREE);
2828 state(data, SSH_STOP);
2833 if(data->state.upload)
2834 state(data, SSH_SCP_SEND_EOF);
2836 state(data, SSH_SCP_CHANNEL_FREE);
2849 infof(data, "Failed to send libssh2 channel EOF: %d %s",
2853 state(data, SSH_SCP_WAIT_EOF);
2866 infof(data, "Failed to get channel EOF: %d %s", rc, err_msg);
2869 state(data, SSH_SCP_WAIT_CLOSE);
2882 infof(data, "Channel failed to close: %d %s", rc, err_msg);
2885 state(data, SSH_SCP_CHANNEL_FREE);
2898 infof(data, "Failed to free libssh2 scp subsystem: %d %s",
2903 DEBUGF(infof(data, "SCP DONE phase complete"));
2905 state(data, SSH_SESSION_DISCONNECT);
2907 state(data, SSH_STOP);
2924 infof(data, "Failed to free libssh2 scp subsystem: %d %s",
2939 infof(data, "Failed to disconnect libssh2 session: %d %s",
2945 data->state.most_recent_ftp_entrypath = NULL;
2947 state(data, SSH_SESSION_FREE);
2968 infof(data, "Failed to disconnect from libssh2 agent: %d %s",
2990 infof(data, "Failed to free libssh2 session: %d %s", rc, err_msg);
3022 state(data, SSH_STOP);
3029 state(data, SSH_STOP);
3046 static int ssh_getsock(struct Curl_easy *data,
3051 (void)data;
3071 static void ssh_block2waitfor(struct Curl_easy *data, bool block)
3073 struct connectdata *conn = data->conn;
3091 static CURLcode ssh_multi_statemach(struct Curl_easy *data, bool *done)
3093 struct connectdata *conn = data->conn;
3099 result = ssh_statemach_act(data, &block);
3104 ssh_block2waitfor(data, block);
3109 static CURLcode ssh_block_statemach(struct Curl_easy *data,
3122 result = ssh_statemach_act(data, &block);
3127 if(Curl_pgrsUpdate(data))
3130 result = Curl_speedcheck(data, now);
3134 left = Curl_timeleft(data, NULL, FALSE);
3136 failf(data, "Operation timed out");
3142 failf(data, "Disconnect timed out");
3168 static CURLcode ssh_setup_connection(struct Curl_easy *data,
3174 data->req.p.ssh = ssh = calloc(1, sizeof(struct SSHPROTO));
3188 struct Curl_easy *data = (struct Curl_easy *)*abstract;
3191 struct connectdata *conn = data->conn;
3199 result = Curl_read(data, sock, buffer, length, &nread);
3205 Curl_debug(data, CURLINFO_DATA_IN, (char *)buffer, (size_t)nread);
3212 struct Curl_easy *data = (struct Curl_easy *)*abstract;
3215 struct connectdata *conn = data->conn;
3223 result = Curl_write(data, sock, buffer, length, &nwrite);
3229 Curl_debug(data, CURLINFO_DATA_OUT, (char *)buffer, (size_t)nwrite);
3238 static CURLcode ssh_connect(struct Curl_easy *data, bool *done)
3245 struct connectdata *conn = data->conn;
3247 /* initialize per-handle data if not already */
3248 if(!data->req.p.ssh) {
3249 result = ssh_setup_connection(data, conn);
3262 infof(data, "User: %s", conn->user);
3265 infof(data, "Password: %s", conn->passwd);
3274 my_libssh2_realloc, data);
3277 failf(data, "Failure initialising ssh session");
3284 if(data->set.server_response_timeout > 0) {
3286 data->set.server_response_timeout / 1000);
3306 infof(data, "Uses HTTPS proxy");
3333 infof(data, "Uses HTTPS proxy");
3356 if(data->set.ssh_compression) {
3360 infof(data, "Failed to enable compression for ssh session");
3364 if(data->set.str[STRING_SSH_KNOWNHOSTS]) {
3375 data->set.str[STRING_SSH_KNOWNHOSTS],
3378 infof(data, "Failed to read known hosts from %s",
3379 data->set.str[STRING_SSH_KNOWNHOSTS]);
3385 infof(data, "SSH socket: %d", (int)sock);
3388 state(data, SSH_INIT);
3390 result = ssh_multi_statemach(data, done);
3405 CURLcode scp_perform(struct Curl_easy *data,
3411 DEBUGF(infof(data, "DO phase starts"));
3416 state(data, SSH_SCP_TRANS_INIT);
3419 result = ssh_multi_statemach(data, dophase_done);
3421 *connected = Curl_conn_is_connected(data->conn, FIRSTSOCKET);
3424 DEBUGF(infof(data, "DO phase is complete"));
3431 static CURLcode scp_doing(struct Curl_easy *data,
3435 result = ssh_multi_statemach(data, dophase_done);
3438 DEBUGF(infof(data, "DO phase is complete"));
3448 static CURLcode ssh_do(struct Curl_easy *data, bool *done)
3452 struct connectdata *conn = data->conn;
3457 data->req.size = -1; /* make sure this is unknown at this point */
3463 Curl_pgrsSetUploadCounter(data, 0);
3464 Curl_pgrsSetDownloadCounter(data, 0);
3465 Curl_pgrsSetUploadSize(data, -1);
3466 Curl_pgrsSetDownloadSize(data, -1);
3469 result = scp_perform(data, &connected, done);
3471 result = sftp_perform(data, &connected, done);
3479 static CURLcode scp_disconnect(struct Curl_easy *data,
3489 state(data, SSH_SESSION_DISCONNECT);
3490 result = ssh_block_statemach(data, conn, TRUE);
3498 static CURLcode ssh_done(struct Curl_easy *data, CURLcode status)
3501 struct SSHPROTO *sshp = data->req.p.ssh;
3502 struct connectdata *conn = data->conn;
3506 result = ssh_block_statemach(data, conn, FALSE);
3515 if(Curl_pgrsDone(data))
3518 data->req.keepon = 0; /* clear all bits */
3523 static CURLcode scp_done(struct Curl_easy *data, CURLcode status,
3529 state(data, SSH_SCP_DONE);
3531 return ssh_done(data, status);
3535 static ssize_t scp_send(struct Curl_easy *data, int sockindex,
3539 struct connectdata *conn = data->conn;
3546 ssh_block2waitfor(data, (nwrite == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
3560 static ssize_t scp_recv(struct Curl_easy *data, int sockindex,
3564 struct connectdata *conn = data->conn;
3571 ssh_block2waitfor(data, (nread == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
3594 CURLcode sftp_perform(struct Curl_easy *data,
3600 DEBUGF(infof(data, "DO phase starts"));
3605 state(data, SSH_SFTP_QUOTE_INIT);
3608 result = ssh_multi_statemach(data, dophase_done);
3610 *connected = Curl_conn_is_connected(data->conn, FIRSTSOCKET);
3613 DEBUGF(infof(data, "DO phase is complete"));
3620 static CURLcode sftp_doing(struct Curl_easy *data,
3623 CURLcode result = ssh_multi_statemach(data, dophase_done);
3626 DEBUGF(infof(data, "DO phase is complete"));
3634 static CURLcode sftp_disconnect(struct Curl_easy *data,
3641 DEBUGF(infof(data, "SSH DISCONNECT starts now"));
3645 state(data, SSH_SFTP_SHUTDOWN);
3646 result = ssh_block_statemach(data, conn, TRUE);
3649 DEBUGF(infof(data, "SSH DISCONNECT is done"));
3655 static CURLcode sftp_done(struct Curl_easy *data, CURLcode status,
3658 struct connectdata *conn = data->conn;
3665 if(!premature && data->set.postquote && !conn->bits.retry)
3667 state(data, SSH_SFTP_CLOSE);
3669 return ssh_done(data, status);
3673 static ssize_t sftp_send(struct Curl_easy *data, int sockindex,
3677 struct connectdata *conn = data->conn;
3683 ssh_block2waitfor(data, (nwrite == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
3701 static ssize_t sftp_recv(struct Curl_easy *data, int sockindex,
3705 struct connectdata *conn = data->conn;
3711 ssh_block2waitfor(data, (nread == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
3817 static void ssh_attach(struct Curl_easy *data, struct connectdata *conn)
3819 DEBUGASSERT(data);
3826 *abstract = data;