34 #include <libssh2_sftp.h> 40 #ifdef HAVE_NETINET_IN_H 41 #include <netinet/in.h> 43 #ifdef HAVE_ARPA_INET_H 44 #include <arpa/inet.h> 47 #include <sys/utsname.h> 57 #if (defined(NETWARE) && defined(__NOVELL_LIBC__)) 59 #define in_addr_t unsigned long 94 # define PATH_MAX MAX_PATH 101 #define PATH_MAX 1024 105 #if LIBSSH2_VERSION_NUM >= 0x010206 107 #define HAS_STATVFS_SUPPORT 1 110 #define sftp_libssh2_last_error(s) curlx_ultosi(libssh2_sftp_last_error(s)) 112 #define sftp_libssh2_realpath(s,p,t,m) \ 113 libssh2_sftp_symlink_ex((s), (p), curlx_uztoui(strlen(p)), \ 114 (t), (m), LIBSSH2_SFTP_REALPATH) 118 static const char *sftp_libssh2_strerror(
int err);
119 static LIBSSH2_ALLOC_FUNC(my_libssh2_malloc);
120 static LIBSSH2_REALLOC_FUNC(my_libssh2_realloc);
121 static LIBSSH2_FREE_FUNC(my_libssh2_free);
123 static CURLcode get_pathname(
const char **cpp,
char **
path);
154 static int ssh_perform_getsock(
const struct connectdata *conn,
167 ssh_setup_connection,
194 ssh_setup_connection,
215 kbd_callback(
const char *
name,
int name_len,
const char *instruction,
216 int instruction_len,
int num_prompts,
217 const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
218 LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
223 #ifdef CURL_LIBSSH2_DEBUG 224 fprintf(stderr,
"name=%s\n", name);
225 fprintf(stderr,
"name_len=%d\n", name_len);
226 fprintf(stderr,
"instruction=%s\n", instruction);
227 fprintf(stderr,
"instruction_len=%d\n", instruction_len);
228 fprintf(stderr,
"num_prompts=%d\n", num_prompts);
233 (void)instruction_len;
235 if(num_prompts == 1) {
243 static CURLcode sftp_libssh2_error_to_CURLE(
int err)
249 case LIBSSH2_FX_NO_SUCH_FILE:
250 case LIBSSH2_FX_NO_SUCH_PATH:
253 case LIBSSH2_FX_PERMISSION_DENIED:
254 case LIBSSH2_FX_WRITE_PROTECT:
255 case LIBSSH2_FX_LOCK_CONFlICT:
258 case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:
259 case LIBSSH2_FX_QUOTA_EXCEEDED:
262 case LIBSSH2_FX_FILE_ALREADY_EXISTS:
265 case LIBSSH2_FX_DIR_NOT_EMPTY:
275 static CURLcode libssh2_session_error_to_CURLE(
int err)
279 case LIBSSH2_ERROR_NONE:
282 case LIBSSH2_ERROR_SOCKET_NONE:
285 case LIBSSH2_ERROR_ALLOC:
288 case LIBSSH2_ERROR_SOCKET_SEND:
291 case LIBSSH2_ERROR_HOSTKEY_INIT:
292 case LIBSSH2_ERROR_HOSTKEY_SIGN:
293 case LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED:
294 case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:
297 case LIBSSH2_ERROR_PASSWORD_EXPIRED:
300 case LIBSSH2_ERROR_SOCKET_TIMEOUT:
301 case LIBSSH2_ERROR_TIMEOUT:
304 case LIBSSH2_ERROR_EAGAIN:
315 static LIBSSH2_ALLOC_FUNC(my_libssh2_malloc)
321 static LIBSSH2_REALLOC_FUNC(my_libssh2_realloc)
327 static LIBSSH2_FREE_FUNC(my_libssh2_free)
341 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS) 343 static const char *
const names[] = {
349 "SSH_AUTH_PKEY_INIT",
351 "SSH_AUTH_PASS_INIT",
353 "SSH_AUTH_AGENT_INIT",
354 "SSH_AUTH_AGENT_LIST",
356 "SSH_AUTH_HOST_INIT",
363 "SSH_SFTP_QUOTE_INIT",
364 "SSH_SFTP_POSTQUOTE_INIT",
366 "SSH_SFTP_NEXT_QUOTE",
367 "SSH_SFTP_QUOTE_STAT",
368 "SSH_SFTP_QUOTE_SETSTAT",
369 "SSH_SFTP_QUOTE_SYMLINK",
370 "SSH_SFTP_QUOTE_MKDIR",
371 "SSH_SFTP_QUOTE_RENAME",
372 "SSH_SFTP_QUOTE_RMDIR",
373 "SSH_SFTP_QUOTE_UNLINK",
374 "SSH_SFTP_QUOTE_STATVFS",
377 "SSH_SFTP_TRANS_INIT",
378 "SSH_SFTP_UPLOAD_INIT",
379 "SSH_SFTP_CREATE_DIRS_INIT",
380 "SSH_SFTP_CREATE_DIRS",
381 "SSH_SFTP_CREATE_DIRS_MKDIR",
382 "SSH_SFTP_READDIR_INIT",
384 "SSH_SFTP_READDIR_LINK",
385 "SSH_SFTP_READDIR_BOTTOM",
386 "SSH_SFTP_READDIR_DONE",
387 "SSH_SFTP_DOWNLOAD_INIT",
388 "SSH_SFTP_DOWNLOAD_STAT",
391 "SSH_SCP_TRANS_INIT",
392 "SSH_SCP_UPLOAD_INIT",
393 "SSH_SCP_DOWNLOAD_INIT",
397 "SSH_SCP_WAIT_CLOSE",
398 "SSH_SCP_CHANNEL_FREE",
399 "SSH_SESSION_DISCONNECT",
404 if(sshc->state != nowstate) {
405 infof(conn->
data,
"SFTP %p state change from %s to %s\n",
406 (
void *)sshc, names[sshc->state], names[nowstate]);
410 sshc->state = nowstate;
420 char *real_path = NULL;
422 size_t working_path_len;
425 &working_path_len,
FALSE);
431 real_path =
malloc(working_path_len + 1);
432 if(real_path == NULL) {
436 if((working_path_len > 3) && (!memcmp(working_path,
"/~/", 3)))
438 memcpy(real_path, working_path + 3, 4 + working_path_len-3);
440 memcpy(real_path, working_path, 1 + working_path_len);
443 if((working_path_len > 1) && (working_path[1] ==
'~')) {
444 size_t homelen = strlen(homedir);
445 real_path =
malloc(homelen + working_path_len + 1);
446 if(real_path == NULL) {
452 memcpy(real_path, homedir, homelen);
453 real_path[homelen] =
'/';
454 real_path[homelen + 1] =
'\0';
455 if(working_path_len > 3) {
456 memcpy(real_path + homelen + 1, working_path + 3,
457 1 + working_path_len -3);
461 real_path =
malloc(working_path_len + 1);
462 if(real_path == NULL) {
466 memcpy(real_path, working_path, 1 + working_path_len);
478 #ifdef HAVE_LIBSSH2_KNOWNHOST_API 499 #ifdef HAVE_LIBSSH2_SFTP_SEEK64 500 #define SFTP_SEEK(x,y) libssh2_sftp_seek64(x, (libssh2_uint64_t)y) 502 #define SFTP_SEEK(x,y) libssh2_sftp_seek(x, (size_t)y) 509 #ifndef HAVE_LIBSSH2_SCP_SEND64 510 #define SCP_SEND(a,b,c,d) libssh2_scp_send_ex(a, b, (int)(c), (size_t)d, 0, 0) 512 #define SCP_SEND(a,b,c,d) libssh2_scp_send64(a, b, (int)(c), \ 513 (libssh2_uint64_t)d, 0, 0) 519 #ifdef HAVE_LIBSSH2_SESSION_HANDSHAKE 520 #define libssh2_session_startup(x,y) libssh2_session_handshake(x,y) 527 #ifdef HAVE_LIBSSH2_KNOWNHOST_API 530 if(data->
set.
str[STRING_SSH_KNOWNHOSTS]) {
536 const char *remotekey = libssh2_session_hostkey(sshc->ssh_session,
538 int keycheck = LIBSSH2_KNOWNHOST_CHECK_FAILURE;
547 struct libssh2_knownhost *host;
555 keybit = (keytype == LIBSSH2_HOSTKEY_TYPE_RSA)?
556 LIBSSH2_KNOWNHOST_KEY_SSHRSA:LIBSSH2_KNOWNHOST_KEY_SSHDSS;
558 #ifdef HAVE_LIBSSH2_KNOWNHOST_CHECKP 559 keycheck = libssh2_knownhost_checkp(sshc->kh,
564 LIBSSH2_KNOWNHOST_TYPE_PLAIN|
565 LIBSSH2_KNOWNHOST_KEYENC_RAW|
569 keycheck = libssh2_knownhost_check(sshc->kh,
572 LIBSSH2_KNOWNHOST_TYPE_PLAIN|
573 LIBSSH2_KNOWNHOST_KEYENC_RAW|
578 infof(data,
"SSH host check: %d, key: %s\n", keycheck,
579 (keycheck <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH)?
583 if(keycheck <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH) {
584 knownkey.
key = host->key;
586 knownkey.
keytype = (keytype == LIBSSH2_HOSTKEY_TYPE_RSA)?
588 knownkeyp = &knownkey;
592 foundkey.
key = remotekey;
593 foundkey.
len = keylen;
594 foundkey.
keytype = (keytype == LIBSSH2_HOSTKEY_TYPE_RSA)?
605 rc = func(data, knownkeyp,
626 if(keycheck != LIBSSH2_KNOWNHOST_CHECK_MATCH) {
629 int addrc = libssh2_knownhost_add(sshc->kh,
632 LIBSSH2_KNOWNHOST_TYPE_PLAIN|
633 LIBSSH2_KNOWNHOST_KEYENC_RAW|
636 infof(data,
"Warning adding the known host %s failed!\n",
642 libssh2_knownhost_writefile(sshc->kh,
643 data->
set.
str[STRING_SSH_KNOWNHOSTS],
644 LIBSSH2_KNOWNHOST_FILE_OPENSSH);
646 infof(data,
"Warning, writing %s failed!\n",
647 data->
set.
str[STRING_SSH_KNOWNHOSTS]);
664 const char *pubkey_md5 = data->
set.
str[STRING_SSH_HOST_PUBLIC_KEY_MD5];
668 const char *fingerprint = libssh2_hostkey_hash(sshc->ssh_session,
669 LIBSSH2_HOSTKEY_HASH_MD5);
673 for(i = 0; i < 16; i++)
674 snprintf(&md5buffer[i*2], 3,
"%02x", (
unsigned char) fingerprint[i]);
675 infof(data,
"SSH MD5 fingerprint: %s\n", md5buffer);
681 if(pubkey_md5 && strlen(pubkey_md5) == 32) {
685 "Denied establishing ssh session: mismatch md5 fingerprint. " 686 "Remote %s is not equal to %s", md5buffer, pubkey_md5);
689 "Denied establishing ssh session: md5 fingerprint not available");
692 return sshc->actualcode;
694 infof(data,
"MD5 checksum match!\n");
698 return ssh_knownhost(conn);
715 char *new_readdir_line;
716 int rc = LIBSSH2_ERROR_NONE;
723 switch(sshc->state) {
725 sshc->secondCreateDirs = 0;
731 libssh2_session_set_blocking(sshc->ssh_session, 0);
737 rc = libssh2_session_startup(sshc->ssh_session, (
int)sock);
738 if(rc == LIBSSH2_ERROR_EAGAIN) {
742 failf(data,
"Failure establishing ssh session");
757 result = ssh_check_fingerprint(conn);
774 sshc->
authlist = libssh2_userauth_list(sshc->ssh_session,
779 if(libssh2_userauth_authenticated(sshc->ssh_session)) {
781 infof(data,
"SSH user accepted with no authentication\n");
785 err = libssh2_session_last_errno(sshc->ssh_session);
786 if(err == LIBSSH2_ERROR_EAGAIN)
787 rc = LIBSSH2_ERROR_EAGAIN;
790 sshc->actualcode = libssh2_session_error_to_CURLE(err);
794 infof(data,
"SSH authentication methods available: %s\n",
805 sshc->authed =
FALSE;
808 (strstr(sshc->
authlist,
"publickey") != NULL)) {
810 bool out_of_memory =
FALSE;
812 sshc->rsa_pub = sshc->rsa = NULL;
818 if(data->
set.
str[STRING_SSH_PRIVATE_KEY])
819 sshc->rsa =
strdup(data->
set.
str[STRING_SSH_PRIVATE_KEY]);
824 sshc->rsa =
aprintf(
"%s/.ssh/id_rsa", home);
826 out_of_memory =
TRUE;
827 else if(access(sshc->rsa, R_OK) != 0) {
829 sshc->rsa =
aprintf(
"%s/.ssh/id_dsa", home);
831 out_of_memory =
TRUE;
832 else if(access(sshc->rsa, R_OK) != 0) {
837 if(!out_of_memory && !sshc->rsa) {
839 sshc->rsa =
strdup(
"id_rsa");
840 if(sshc->rsa && access(sshc->rsa, R_OK) != 0) {
842 sshc->rsa =
strdup(
"id_dsa");
843 if(sshc->rsa && access(sshc->rsa, R_OK) != 0) {
858 if(data->
set.
str[STRING_SSH_PUBLIC_KEY]
860 && data->
set.
str[STRING_SSH_PUBLIC_KEY][0]) {
861 sshc->rsa_pub =
strdup(data->
set.
str[STRING_SSH_PUBLIC_KEY]);
863 out_of_memory =
TRUE;
866 if(out_of_memory || sshc->rsa == NULL) {
876 if(!sshc->passphrase)
877 sshc->passphrase =
"";
882 infof(data,
"Using SSH public key file '%s'\n", sshc->rsa_pub);
883 infof(data,
"Using SSH private key file '%s'\n", sshc->rsa);
895 rc = libssh2_userauth_publickey_fromfile_ex(sshc->ssh_session,
900 sshc->rsa, sshc->passphrase);
901 if(rc == LIBSSH2_ERROR_EAGAIN) {
910 infof(data,
"Initialized SSH public key authentication\n");
915 (void)libssh2_session_last_error(sshc->ssh_session,
917 infof(data,
"SSH public key authentication failed: %s\n", err_msg);
925 (strstr(sshc->
authlist,
"password") != NULL)) {
935 rc = libssh2_userauth_password_ex(sshc->ssh_session, conn->
user,
940 if(rc == LIBSSH2_ERROR_EAGAIN) {
945 infof(data,
"Initialized password authentication\n");
956 (strstr(sshc->
authlist,
"hostbased") != NULL)) {
969 #ifdef HAVE_LIBSSH2_AGENT_API 971 && (strstr(sshc->
authlist,
"publickey") != NULL)) {
976 if(!sshc->ssh_agent) {
977 sshc->ssh_agent = libssh2_agent_init(sshc->ssh_session);
978 if(!sshc->ssh_agent) {
979 infof(data,
"Could not create agent object\n");
986 rc = libssh2_agent_connect(sshc->ssh_agent);
987 if(rc == LIBSSH2_ERROR_EAGAIN)
990 infof(data,
"Failure connecting to agent\n");
1004 #ifdef HAVE_LIBSSH2_AGENT_API 1005 rc = libssh2_agent_list_identities(sshc->ssh_agent);
1007 if(rc == LIBSSH2_ERROR_EAGAIN)
1010 infof(data,
"Failure requesting identities to agent\n");
1016 sshc->sshagent_prev_identity = NULL;
1022 #ifdef HAVE_LIBSSH2_AGENT_API 1026 rc = libssh2_agent_get_identity(sshc->ssh_agent,
1027 &sshc->sshagent_identity,
1028 sshc->sshagent_prev_identity);
1029 if(rc == LIBSSH2_ERROR_EAGAIN)
1033 rc = libssh2_agent_userauth(sshc->ssh_agent, conn->
user,
1034 sshc->sshagent_identity);
1037 if(rc != LIBSSH2_ERROR_EAGAIN)
1039 sshc->sshagent_prev_identity = sshc->sshagent_identity;
1046 infof(data,
"Failure requesting identities to agent\n");
1048 infof(data,
"No identity would match\n");
1050 if(rc == LIBSSH2_ERROR_NONE) {
1051 sshc->authed =
TRUE;
1052 infof(data,
"Agent based authentication successful\n");
1064 && (strstr(sshc->
authlist,
"keyboard-interactive") != NULL)) {
1074 rc = libssh2_userauth_keyboard_interactive_ex(sshc->ssh_session,
1077 strlen(conn->
user)),
1079 if(rc == LIBSSH2_ERROR_EAGAIN) {
1083 sshc->authed =
TRUE;
1084 infof(data,
"Initialized keyboard interactive authentication\n");
1091 failf(data,
"Authentication failure");
1100 infof(data,
"Authentication complete\n");
1111 infof(data,
"SSH CONNECT phase done\n");
1119 sshc->sftp_session = libssh2_sftp_init(sshc->ssh_session);
1120 if(!sshc->sftp_session) {
1122 if(libssh2_session_last_errno(sshc->ssh_session) ==
1123 LIBSSH2_ERROR_EAGAIN) {
1124 rc = LIBSSH2_ERROR_EAGAIN;
1128 (void)libssh2_session_last_error(sshc->ssh_session,
1130 failf(data,
"Failure initializing sftp session: %s", err_msg);
1140 char tempHome[PATH_MAX];
1145 rc = sftp_libssh2_realpath(sshc->sftp_session,
".",
1146 tempHome, PATH_MAX-1);
1147 if(rc == LIBSSH2_ERROR_EAGAIN) {
1152 tempHome[
rc] =
'\0';
1153 sshc->homedir =
strdup(tempHome);
1154 if(!sshc->homedir) {
1163 err = sftp_libssh2_last_error(sshc->sftp_session);
1165 result = sftp_libssh2_error_to_CURLE(err);
1170 sshc->actualcode =
result;
1171 DEBUGF(
infof(data,
"error = %d makes libcurl = %d\n",
1187 result = ssh_getworkingpath(conn, sshc->homedir, &sftp_scp->
path);
1189 sshc->actualcode =
result;
1195 infof(data,
"Sending quote commands\n");
1196 sshc->quote_item = data->
set.
quote;
1206 infof(data,
"Sending quote commands\n");
1223 char *cmd = sshc->quote_item->data;
1224 sshc->acceptfail =
FALSE;
1233 sshc->acceptfail =
TRUE;
1238 char *tmp =
aprintf(
"257 \"%s\" is current directory.\n",
1258 sshc->actualcode =
result;
1269 cp = strchr(cmd,
' ');
1271 failf(data,
"Syntax error in SFTP command. Supply parameter(s)!");
1282 result = get_pathname(&cp, &sshc->quote_path1);
1285 failf(data,
"Out of memory");
1287 failf(data,
"Syntax error: Bad first parameter");
1290 sshc->actualcode =
result;
1307 result = get_pathname(&cp, &sshc->quote_path2);
1310 failf(data,
"Out of memory");
1312 failf(data,
"Syntax error in chgrp/chmod/chown: " 1313 "Bad second parameter");
1317 sshc->actualcode =
result;
1320 memset(&sshc->quote_attrs, 0,
sizeof(LIBSSH2_SFTP_ATTRIBUTES));
1329 result = get_pathname(&cp, &sshc->quote_path2);
1332 failf(data,
"Out of memory");
1335 "Syntax error in ln/symlink: Bad second parameter");
1339 sshc->actualcode =
result;
1354 result = get_pathname(&cp, &sshc->quote_path2);
1357 failf(data,
"Out of memory");
1359 failf(data,
"Syntax error in rename: Bad second parameter");
1363 sshc->actualcode =
result;
1378 #ifdef HAS_STATVFS_SUPPORT 1385 failf(data,
"Unknown SFTP command");
1394 if(!sshc->quote_item) {
1403 sshc->quote_item = sshc->quote_item->next;
1405 if(sshc->quote_item) {
1410 state(conn, sshc->nextstate);
1421 char *cmd = sshc->quote_item->data;
1422 sshc->acceptfail =
FALSE;
1431 sshc->acceptfail =
TRUE;
1439 rc = libssh2_sftp_stat_ex(sshc->sftp_session, sshc->quote_path2,
1442 &sshc->quote_attrs);
1443 if(rc == LIBSSH2_ERROR_EAGAIN) {
1446 if(rc != 0 && !sshc->acceptfail) {
1447 err = sftp_libssh2_last_error(sshc->sftp_session);
1450 failf(data,
"Attempt to get SFTP stats failed: %s",
1451 sftp_libssh2_strerror(err));
1461 sshc->quote_attrs.gid = strtoul(sshc->quote_path1, NULL, 10);
1462 sshc->quote_attrs.flags = LIBSSH2_SFTP_ATTR_UIDGID;
1463 if(sshc->quote_attrs.gid == 0 && !
ISDIGIT(sshc->quote_path1[0]) &&
1464 !sshc->acceptfail) {
1467 failf(data,
"Syntax error: chgrp gid not a number");
1475 sshc->quote_attrs.permissions = strtoul(sshc->quote_path1, NULL, 8);
1476 sshc->quote_attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS;
1478 if(sshc->quote_attrs.permissions == 0 &&
1479 !
ISDIGIT(sshc->quote_path1[0])) {
1482 failf(data,
"Syntax error: chmod permissions not a number");
1490 sshc->quote_attrs.uid = strtoul(sshc->quote_path1, NULL, 10);
1491 sshc->quote_attrs.flags = LIBSSH2_SFTP_ATTR_UIDGID;
1492 if(sshc->quote_attrs.uid == 0 && !
ISDIGIT(sshc->quote_path1[0]) &&
1493 !sshc->acceptfail) {
1496 failf(data,
"Syntax error: chown uid not a number");
1510 rc = libssh2_sftp_stat_ex(sshc->sftp_session, sshc->quote_path2,
1512 LIBSSH2_SFTP_SETSTAT,
1513 &sshc->quote_attrs);
1514 if(rc == LIBSSH2_ERROR_EAGAIN) {
1517 if(rc != 0 && !sshc->acceptfail) {
1518 err = sftp_libssh2_last_error(sshc->sftp_session);
1521 failf(data,
"Attempt to set SFTP stats failed: %s",
1522 sftp_libssh2_strerror(err));
1532 rc = libssh2_sftp_symlink_ex(sshc->sftp_session, sshc->quote_path1,
1536 LIBSSH2_SFTP_SYMLINK);
1537 if(rc == LIBSSH2_ERROR_EAGAIN) {
1540 if(rc != 0 && !sshc->acceptfail) {
1541 err = sftp_libssh2_last_error(sshc->sftp_session);
1544 failf(data,
"symlink command failed: %s",
1545 sftp_libssh2_strerror(err));
1555 rc = libssh2_sftp_mkdir_ex(sshc->sftp_session, sshc->quote_path1,
1558 if(rc == LIBSSH2_ERROR_EAGAIN) {
1561 if(rc != 0 && !sshc->acceptfail) {
1562 err = sftp_libssh2_last_error(sshc->sftp_session);
1564 failf(data,
"mkdir command failed: %s", sftp_libssh2_strerror(err));
1574 rc = libssh2_sftp_rename_ex(sshc->sftp_session, sshc->quote_path1,
1578 LIBSSH2_SFTP_RENAME_OVERWRITE |
1579 LIBSSH2_SFTP_RENAME_ATOMIC |
1580 LIBSSH2_SFTP_RENAME_NATIVE);
1582 if(rc == LIBSSH2_ERROR_EAGAIN) {
1585 if(rc != 0 && !sshc->acceptfail) {
1586 err = sftp_libssh2_last_error(sshc->sftp_session);
1589 failf(data,
"rename command failed: %s", sftp_libssh2_strerror(err));
1599 rc = libssh2_sftp_rmdir_ex(sshc->sftp_session, sshc->quote_path1,
1601 if(rc == LIBSSH2_ERROR_EAGAIN) {
1604 if(rc != 0 && !sshc->acceptfail) {
1605 err = sftp_libssh2_last_error(sshc->sftp_session);
1607 failf(data,
"rmdir command failed: %s", sftp_libssh2_strerror(err));
1617 rc = libssh2_sftp_unlink_ex(sshc->sftp_session, sshc->quote_path1,
1619 if(rc == LIBSSH2_ERROR_EAGAIN) {
1622 if(rc != 0 && !sshc->acceptfail) {
1623 err = sftp_libssh2_last_error(sshc->sftp_session);
1625 failf(data,
"rm command failed: %s", sftp_libssh2_strerror(err));
1634 #ifdef HAS_STATVFS_SUPPORT 1637 LIBSSH2_SFTP_STATVFS statvfs;
1638 rc = libssh2_sftp_statvfs(sshc->sftp_session, sshc->quote_path1,
1642 if(rc == LIBSSH2_ERROR_EAGAIN) {
1645 if(rc != 0 && !sshc->acceptfail) {
1646 err = sftp_libssh2_last_error(sshc->sftp_session);
1648 failf(data,
"statvfs command failed: %s", sftp_libssh2_strerror(err));
1655 char *tmp =
aprintf(
"statvfs:\n" 1656 "f_bsize: %llu\n" "f_frsize: %llu\n" 1657 "f_blocks: %llu\n" "f_bfree: %llu\n" 1658 "f_bavail: %llu\n" "f_files: %llu\n" 1659 "f_ffree: %llu\n" "f_favail: %llu\n" 1660 "f_fsid: %llu\n" "f_flag: %llu\n" 1661 "f_namemax: %llu\n",
1662 statvfs.f_bsize, statvfs.f_frsize,
1663 statvfs.f_blocks, statvfs.f_bfree,
1664 statvfs.f_bavail, statvfs.f_files,
1665 statvfs.f_ffree, statvfs.f_favail,
1666 statvfs.f_fsid, statvfs.f_flag,
1680 sshc->actualcode =
result;
1700 LIBSSH2_SFTP_ATTRIBUTES attrs;
1702 rc = libssh2_sftp_stat_ex(sshc->sftp_session, sftp_scp->
path,
1704 LIBSSH2_SFTP_STAT, &attrs);
1705 if(rc == LIBSSH2_ERROR_EAGAIN) {
1720 if(sftp_scp->
path[strlen(sftp_scp->
path)-1] ==
'/')
1729 unsigned long flags;
1738 LIBSSH2_SFTP_ATTRIBUTES attrs;
1740 rc = libssh2_sftp_stat_ex(sshc->sftp_session, sftp_scp->
path,
1742 LIBSSH2_SFTP_STAT, &attrs);
1743 if(rc == LIBSSH2_ERROR_EAGAIN) {
1762 flags = LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|LIBSSH2_FXF_APPEND;
1765 flags = LIBSSH2_FXF_WRITE|LIBSSH2_FXF_APPEND;
1768 flags = LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|LIBSSH2_FXF_TRUNC;
1771 libssh2_sftp_open_ex(sshc->sftp_session, sftp_scp->
path,
1774 LIBSSH2_SFTP_OPENFILE);
1776 if(!sshc->sftp_handle) {
1777 rc = libssh2_session_last_errno(sshc->ssh_session);
1779 if(LIBSSH2_ERROR_EAGAIN == rc)
1782 if(LIBSSH2_ERROR_SFTP_PROTOCOL == rc)
1785 err = sftp_libssh2_last_error(sshc->sftp_session);
1789 if(sshc->secondCreateDirs) {
1791 sshc->actualcode = err>= LIBSSH2_FX_OK?
1792 sftp_libssh2_error_to_CURLE(err):
CURLE_SSH;
1793 failf(data,
"Creating the dir/file failed: %s",
1794 sftp_libssh2_strerror(err));
1797 if(((err == LIBSSH2_FX_NO_SUCH_FILE) ||
1798 (err == LIBSSH2_FX_FAILURE) ||
1799 (err == LIBSSH2_FX_NO_SUCH_PATH)) &&
1801 (strlen(sftp_scp->
path) > 1))) {
1804 sshc->secondCreateDirs = 1;
1809 sshc->actualcode = err>= LIBSSH2_FX_OK?
1810 sftp_libssh2_error_to_CURLE(err):
CURLE_SSH;
1811 if(!sshc->actualcode) {
1818 failf(data,
"Upload failed: %s (%d/%d)",
1819 err>= LIBSSH2_FX_OK?sftp_libssh2_strerror(err):
"ssh error",
1837 failf(data,
"Could not seek stream");
1842 size_t readthisamountnow =
1847 size_t actuallyread =
1849 readthisamountnow, data->
state.
in);
1851 passed += actuallyread;
1852 if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
1855 failf(data,
"Failed to read data");
1858 }
while(passed < data->
state.resume_from);
1882 sshc->actualcode =
result;
1905 if(strlen(sftp_scp->
path) > 1) {
1906 sshc->slash_pos = sftp_scp->
path + 1;
1915 sshc->slash_pos = strchr(sshc->slash_pos,
'/');
1916 if(sshc->slash_pos) {
1917 *sshc->slash_pos = 0;
1919 infof(data,
"Creating directory '%s'\n", sftp_scp->
path);
1928 rc = libssh2_sftp_mkdir_ex(sshc->sftp_session, sftp_scp->
path,
1931 if(rc == LIBSSH2_ERROR_EAGAIN) {
1934 *sshc->slash_pos =
'/';
1942 err = sftp_libssh2_last_error(sshc->sftp_session);
1943 if((err != LIBSSH2_FX_FILE_ALREADY_EXISTS) &&
1944 (err != LIBSSH2_FX_FAILURE) &&
1945 (err != LIBSSH2_FX_PERMISSION_DENIED)) {
1946 result = sftp_libssh2_error_to_CURLE(err);
1948 sshc->actualcode = result?result:
CURLE_SSH;
1967 sshc->sftp_handle = libssh2_sftp_open_ex(sshc->sftp_session,
1970 strlen(sftp_scp->
path)),
1971 0, 0, LIBSSH2_SFTP_OPENDIR);
1972 if(!sshc->sftp_handle) {
1973 if(libssh2_session_last_errno(sshc->ssh_session) ==
1974 LIBSSH2_ERROR_EAGAIN) {
1975 rc = LIBSSH2_ERROR_EAGAIN;
1978 err = sftp_libssh2_last_error(sshc->sftp_session);
1979 failf(data,
"Could not open directory for reading: %s",
1980 sftp_libssh2_strerror(err));
1982 result = sftp_libssh2_error_to_CURLE(err);
1983 sshc->actualcode = result?result:
CURLE_SSH;
1986 sshc->readdir_filename =
malloc(PATH_MAX + 1);
1987 if(!sshc->readdir_filename) {
1992 sshc->readdir_longentry =
malloc(PATH_MAX + 1);
1993 if(!sshc->readdir_longentry) {
2003 sshc->readdir_len = libssh2_sftp_readdir_ex(sshc->sftp_handle,
2004 sshc->readdir_filename,
2006 sshc->readdir_longentry,
2008 &sshc->readdir_attrs);
2009 if(sshc->readdir_len == LIBSSH2_ERROR_EAGAIN) {
2010 rc = LIBSSH2_ERROR_EAGAIN;
2013 if(sshc->readdir_len > 0) {
2014 sshc->readdir_filename[sshc->readdir_len] =
'\0';
2019 tmpLine =
aprintf(
"%s\n", sshc->readdir_filename);
2020 if(tmpLine == NULL) {
2026 tmpLine, sshc->readdir_len + 1);
2040 sshc->readdir_len, conn);
2044 sshc->readdir_currLen = (int)strlen(sshc->readdir_longentry);
2045 sshc->readdir_totalLen = 80 + sshc->readdir_currLen;
2046 sshc->readdir_line =
calloc(sshc->readdir_totalLen, 1);
2047 if(!sshc->readdir_line) {
2055 memcpy(sshc->readdir_line, sshc->readdir_longentry,
2056 sshc->readdir_currLen);
2057 if((sshc->readdir_attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) &&
2058 ((sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
2059 LIBSSH2_SFTP_S_IFLNK)) {
2060 sshc->readdir_linkPath =
malloc(PATH_MAX + 1);
2061 if(sshc->readdir_linkPath == NULL) {
2069 snprintf(sshc->readdir_linkPath, PATH_MAX,
"%s%s", sftp_scp->
path,
2070 sshc->readdir_filename);
2078 else if(sshc->readdir_len == 0) {
2084 else if(sshc->readdir_len <= 0) {
2085 err = sftp_libssh2_last_error(sshc->sftp_session);
2086 result = sftp_libssh2_error_to_CURLE(err);
2087 sshc->actualcode = result?result:
CURLE_SSH;
2088 failf(data,
"Could not open remote file for reading: %s :: %d",
2089 sftp_libssh2_strerror(err),
2090 libssh2_session_last_errno(sshc->ssh_session));
2100 libssh2_sftp_symlink_ex(sshc->sftp_session,
2101 sshc->readdir_linkPath,
2103 sshc->readdir_filename,
2104 PATH_MAX, LIBSSH2_SFTP_READLINK);
2105 if(sshc->readdir_len == LIBSSH2_ERROR_EAGAIN) {
2106 rc = LIBSSH2_ERROR_EAGAIN;
2112 sshc->readdir_totalLen += 4 + sshc->readdir_len;
2114 sshc->readdir_totalLen);
2115 if(!new_readdir_line) {
2116 sshc->readdir_line = NULL;
2123 sshc->readdir_line = new_readdir_line;
2125 sshc->readdir_currLen +=
snprintf(sshc->readdir_line +
2126 sshc->readdir_currLen,
2127 sshc->readdir_totalLen -
2128 sshc->readdir_currLen,
2130 sshc->readdir_filename);
2136 sshc->readdir_currLen +=
snprintf(sshc->readdir_line +
2137 sshc->readdir_currLen,
2138 sshc->readdir_totalLen -
2139 sshc->readdir_currLen,
"\n");
2142 sshc->readdir_currLen);
2149 sshc->readdir_currLen, conn);
2162 if(libssh2_sftp_closedir(sshc->sftp_handle) ==
2163 LIBSSH2_ERROR_EAGAIN) {
2164 rc = LIBSSH2_ERROR_EAGAIN;
2167 sshc->sftp_handle = NULL;
2181 libssh2_sftp_open_ex(sshc->sftp_session, sftp_scp->
path,
2184 LIBSSH2_SFTP_OPENFILE);
2185 if(!sshc->sftp_handle) {
2186 if(libssh2_session_last_errno(sshc->ssh_session) ==
2187 LIBSSH2_ERROR_EAGAIN) {
2188 rc = LIBSSH2_ERROR_EAGAIN;
2191 err = sftp_libssh2_last_error(sshc->sftp_session);
2192 failf(data,
"Could not open remote file for reading: %s",
2193 sftp_libssh2_strerror(err));
2195 result = sftp_libssh2_error_to_CURLE(err);
2196 sshc->actualcode = result?result:
CURLE_SSH;
2204 LIBSSH2_SFTP_ATTRIBUTES attrs;
2206 rc = libssh2_sftp_stat_ex(sshc->sftp_session, sftp_scp->
path,
2208 LIBSSH2_SFTP_STAT, &attrs);
2209 if(rc == LIBSSH2_ERROR_EAGAIN) {
2213 !(attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) ||
2214 (attrs.filesize == 0)) {
2242 while(*ptr && (
ISSPACE(*ptr) || (*ptr ==
'-')))
2257 failf(data,
"Offset (%" 2267 size = to - from + 1;
2270 SFTP_SEEK(conn->
proto.
sshc.sftp_handle, from);
2282 failf(data,
"Offset (%" 2313 infof(data,
"File already completely downloaded\n");
2318 FALSE, NULL, -1, NULL);
2332 sshc->actualcode =
result;
2340 if(sshc->sftp_handle) {
2341 rc = libssh2_sftp_close(sshc->sftp_handle);
2342 if(rc == LIBSSH2_ERROR_EAGAIN) {
2346 infof(data,
"Failed to close libssh2 file\n");
2348 sshc->sftp_handle = NULL;
2360 state(conn, sshc->nextstate);
2365 result = sshc->actualcode;
2374 if(sshc->sftp_handle) {
2375 rc = libssh2_sftp_close(sshc->sftp_handle);
2376 if(rc == LIBSSH2_ERROR_EAGAIN) {
2380 infof(data,
"Failed to close libssh2 file\n");
2382 sshc->sftp_handle = NULL;
2384 if(sshc->sftp_session) {
2385 rc = libssh2_sftp_shutdown(sshc->sftp_session);
2386 if(rc == LIBSSH2_ERROR_EAGAIN) {
2390 infof(data,
"Failed to stop libssh2 sftp subsystem\n");
2392 sshc->sftp_session = NULL;
2402 result = ssh_getworkingpath(conn, sshc->homedir, &sftp_scp->
path);
2404 sshc->actualcode =
result;
2411 failf(data,
"SCP requires a known file size for upload");
2433 if(!sshc->ssh_channel) {
2437 if(libssh2_session_last_errno(sshc->ssh_session) ==
2438 LIBSSH2_ERROR_EAGAIN) {
2439 rc = LIBSSH2_ERROR_EAGAIN;
2443 ssh_err = (int)(libssh2_session_last_error(sshc->ssh_session,
2444 &err_msg, NULL, 0));
2447 sshc->actualcode = libssh2_session_error_to_CURLE(ssh_err);
2460 sshc->actualcode =
result;
2490 #if LIBSSH2_VERSION_NUM < 0x010700 2492 memset(&sb, 0,
sizeof(
struct stat));
2493 sshc->ssh_channel = libssh2_scp_recv(sshc->ssh_session,
2494 sftp_scp->
path, &sb);
2496 libssh2_struct_stat sb;
2497 memset(&sb, 0,
sizeof(libssh2_struct_stat));
2498 sshc->ssh_channel = libssh2_scp_recv2(sshc->ssh_session,
2499 sftp_scp->
path, &sb);
2502 if(!sshc->ssh_channel) {
2506 if(libssh2_session_last_errno(sshc->ssh_session) ==
2507 LIBSSH2_ERROR_EAGAIN) {
2508 rc = LIBSSH2_ERROR_EAGAIN;
2513 ssh_err = (int)(libssh2_session_last_error(sshc->ssh_session,
2514 &err_msg, NULL, 0));
2517 sshc->actualcode = libssh2_session_error_to_CURLE(ssh_err);
2536 sshc->actualcode =
result;
2551 if(sshc->ssh_channel) {
2552 rc = libssh2_channel_send_eof(sshc->ssh_channel);
2553 if(rc == LIBSSH2_ERROR_EAGAIN) {
2557 infof(data,
"Failed to send libssh2 channel EOF\n");
2564 if(sshc->ssh_channel) {
2565 rc = libssh2_channel_wait_eof(sshc->ssh_channel);
2566 if(rc == LIBSSH2_ERROR_EAGAIN) {
2570 infof(data,
"Failed to get channel EOF: %d\n", rc);
2577 if(sshc->ssh_channel) {
2578 rc = libssh2_channel_wait_closed(sshc->ssh_channel);
2579 if(rc == LIBSSH2_ERROR_EAGAIN) {
2583 infof(data,
"Channel failed to close: %d\n", rc);
2590 if(sshc->ssh_channel) {
2591 rc = libssh2_channel_free(sshc->ssh_channel);
2592 if(rc == LIBSSH2_ERROR_EAGAIN) {
2596 infof(data,
"Failed to free libssh2 scp subsystem\n");
2598 sshc->ssh_channel = NULL;
2605 result = sshc->actualcode;
2612 if(sshc->ssh_channel) {
2613 rc = libssh2_channel_free(sshc->ssh_channel);
2614 if(rc == LIBSSH2_ERROR_EAGAIN) {
2618 infof(data,
"Failed to free libssh2 scp subsystem\n");
2620 sshc->ssh_channel = NULL;
2623 if(sshc->ssh_session) {
2624 rc = libssh2_session_disconnect(sshc->ssh_session,
"Shutdown");
2625 if(rc == LIBSSH2_ERROR_EAGAIN) {
2629 infof(data,
"Failed to disconnect libssh2 session\n");
2640 #ifdef HAVE_LIBSSH2_KNOWNHOST_API 2642 libssh2_knownhost_free(sshc->kh);
2647 #ifdef HAVE_LIBSSH2_AGENT_API 2648 if(sshc->ssh_agent) {
2649 rc = libssh2_agent_disconnect(sshc->ssh_agent);
2650 if(rc == LIBSSH2_ERROR_EAGAIN) {
2654 infof(data,
"Failed to disconnect from libssh2 agent\n");
2656 libssh2_agent_free(sshc->ssh_agent);
2657 sshc->ssh_agent = NULL;
2661 sshc->sshagent_identity = NULL;
2662 sshc->sshagent_prev_identity = NULL;
2666 if(sshc->ssh_session) {
2667 rc = libssh2_session_free(sshc->ssh_session);
2668 if(rc == LIBSSH2_ERROR_EAGAIN) {
2672 infof(data,
"Failed to free libssh2 session\n");
2674 sshc->ssh_session = NULL;
2683 #ifdef HAVE_LIBSSH2_KNOWNHOST_API 2686 #ifdef HAVE_LIBSSH2_AGENT_API 2704 result = sshc->actualcode;
2706 memset(sshc, 0,
sizeof(
struct ssh_conn));
2723 }
while(!rc && (sshc->state !=
SSH_STOP));
2725 if(rc == LIBSSH2_ERROR_EAGAIN) {
2736 static int ssh_perform_getsock(
const struct connectdata *conn,
2741 #ifdef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION 2768 #ifndef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION 2778 return ssh_perform_getsock(conn, sock, numsocks);
2782 #ifdef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION 2790 static void ssh_block2waitfor(
struct connectdata *conn,
bool block)
2795 dir = libssh2_session_block_directions(sshc->ssh_session);
2799 ((dir&LIBSSH2_SESSION_BLOCK_OUTBOUND)?
KEEP_SEND:0);
2805 conn->
waitfor = sshc->orig_waitfor;
2809 #define ssh_block2waitfor(x,y) Curl_nop_stmt 2820 result = ssh_statemach_act(conn, &block);
2822 ssh_block2waitfor(conn, block);
2834 while((sshc->state !=
SSH_STOP) && !result) {
2839 result = ssh_statemach_act(conn, &block);
2853 failf(data,
"Operation timed out");
2858 #ifdef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION 2859 if(!result && block) {
2860 int dir = libssh2_session_block_directions(sshc->ssh_session);
2864 if(LIBSSH2_SESSION_BLOCK_INBOUND & dir)
2866 if(LIBSSH2_SESSION_BLOCK_OUTBOUND & dir)
2870 left>1000?1000:left);
2902 #ifdef CURL_LIBSSH2_DEBUG 2911 ssh_setup_connection(conn);
2927 #ifdef CURL_LIBSSH2_DEBUG 2937 ssh->ssh_session = libssh2_session_init_ex(my_libssh2_malloc,
2939 my_libssh2_realloc, conn);
2940 if(ssh->ssh_session == NULL) {
2941 failf(data,
"Failure initialising ssh session");
2946 #if LIBSSH2_VERSION_NUM >= 0x010208 2947 if(libssh2_session_flag(ssh->ssh_session, LIBSSH2_FLAG_COMPRESS, 1) < 0)
2949 infof(data,
"Failed to enable compression for ssh session\n");
2952 #ifdef HAVE_LIBSSH2_KNOWNHOST_API 2953 if(data->
set.
str[STRING_SSH_KNOWNHOSTS]) {
2955 ssh->kh = libssh2_knownhost_init(ssh->ssh_session);
2962 rc = libssh2_knownhost_readfile(ssh->kh,
2963 data->
set.
str[STRING_SSH_KNOWNHOSTS],
2964 LIBSSH2_KNOWNHOST_FILE_OPENSSH);
2966 infof(data,
"Failed to read known hosts from %s\n",
2967 data->
set.
str[STRING_SSH_KNOWNHOSTS]);
2971 #ifdef CURL_LIBSSH2_DEBUG 2972 libssh2_trace(ssh->ssh_session, ~0);
2973 infof(data,
"SSH socket: %d\n", (
int)sock);
2978 result = ssh_multi_statemach(conn, done);
3001 *dophase_done =
FALSE;
3007 result = ssh_multi_statemach(conn, dophase_done);
3023 result = ssh_multi_statemach(conn, dophase_done);
3048 sshc->secondCreateDirs = 0;
3057 result = scp_perform(conn, &connected, done);
3059 result = sftp_perform(conn, &connected, done);
3071 (void) dead_connection;
3073 if(ssh->ssh_session) {
3078 result = ssh_block_statemach(conn,
TRUE);
3098 result = ssh_block_statemach(conn,
FALSE);
3121 return ssh_done(conn, status);
3133 libssh2_channel_write(conn->
proto.
sshc.ssh_channel, mem, len);
3135 ssh_block2waitfor(conn, (nwrite == LIBSSH2_ERROR_EAGAIN)?
TRUE:
FALSE);
3137 if(nwrite == LIBSSH2_ERROR_EAGAIN) {
3141 else if(nwrite < LIBSSH2_ERROR_NONE) {
3142 *err = libssh2_session_error_to_CURLE((
int)nwrite);
3150 char *mem,
size_t len,
CURLcode *err)
3157 libssh2_channel_read(conn->
proto.
sshc.ssh_channel, mem, len);
3159 ssh_block2waitfor(conn, (nread == LIBSSH2_ERROR_EAGAIN)?
TRUE:
FALSE);
3160 if(nread == LIBSSH2_ERROR_EAGAIN) {
3190 *dophase_done =
FALSE;
3196 result = ssh_multi_statemach(conn, dophase_done);
3211 CURLcode result = ssh_multi_statemach(conn, dophase_done);
3225 (void) dead_connection;
3232 result = ssh_block_statemach(conn,
TRUE);
3257 return ssh_done(conn, status);
3262 const void *mem,
size_t len,
CURLcode *err)
3269 nwrite = libssh2_sftp_write(conn->
proto.
sshc.sftp_handle, mem, len);
3271 ssh_block2waitfor(conn, (nwrite == LIBSSH2_ERROR_EAGAIN)?
TRUE:
FALSE);
3273 if(nwrite == LIBSSH2_ERROR_EAGAIN) {
3277 else if(nwrite < LIBSSH2_ERROR_NONE) {
3278 *err = libssh2_session_error_to_CURLE((
int)nwrite);
3290 char *mem,
size_t len,
CURLcode *err)
3295 nread = libssh2_sftp_read(conn->
proto.
sshc.sftp_handle, mem, len);
3297 ssh_block2waitfor(conn, (nread == LIBSSH2_ERROR_EAGAIN)?
TRUE:
FALSE);
3299 if(nread == LIBSSH2_ERROR_EAGAIN) {
3304 else if(nread < 0) {
3305 *err = libssh2_session_error_to_CURLE((
int)nread);
3328 get_pathname(
const char **cpp,
char **path)
3330 const char *cp = *cpp, *end;
3333 static const char WHITESPACE[] =
" \t\r\n";
3335 cp += strspn(cp, WHITESPACE);
3342 *path =
malloc(strlen(cp) + 1);
3347 if(*cp ==
'\"' || *cp ==
'\'') {
3351 for(i = j = 0; i <= strlen(cp); i++) {
3363 if(cp[i] !=
'\'' && cp[i] !=
'\"' &&
3370 (*path)[j++] = cp[
i];
3377 *cpp = cp + i + strspn(cp + i, WHITESPACE);
3381 end = strpbrk(cp, WHITESPACE);
3383 end = strchr(cp,
'\0');
3384 *cpp = end + strspn(end, WHITESPACE);
3386 memcpy(*path, cp, end - cp);
3387 (*path)[end - cp] =
'\0';
3397 static const char *sftp_libssh2_strerror(
int err)
3400 case LIBSSH2_FX_NO_SUCH_FILE:
3401 return "No such file or directory";
3403 case LIBSSH2_FX_PERMISSION_DENIED:
3404 return "Permission denied";
3406 case LIBSSH2_FX_FAILURE:
3407 return "Operation failed";
3409 case LIBSSH2_FX_BAD_MESSAGE:
3410 return "Bad message from SFTP server";
3412 case LIBSSH2_FX_NO_CONNECTION:
3413 return "Not connected to SFTP server";
3415 case LIBSSH2_FX_CONNECTION_LOST:
3416 return "Connection to SFTP server lost";
3418 case LIBSSH2_FX_OP_UNSUPPORTED:
3419 return "Operation not supported by SFTP server";
3421 case LIBSSH2_FX_INVALID_HANDLE:
3422 return "Invalid handle";
3424 case LIBSSH2_FX_NO_SUCH_PATH:
3425 return "No such file or directory";
3427 case LIBSSH2_FX_FILE_ALREADY_EXISTS:
3428 return "File already exists";
3430 case LIBSSH2_FX_WRITE_PROTECT:
3431 return "File is write protected";
3433 case LIBSSH2_FX_NO_MEDIA:
3436 case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:
3439 case LIBSSH2_FX_QUOTA_EXCEEDED:
3440 return "User quota exceeded";
3442 case LIBSSH2_FX_UNKNOWN_PRINCIPLE:
3443 return "Unknown principle";
3445 case LIBSSH2_FX_LOCK_CONFlICT:
3446 return "File lock conflict";
3448 case LIBSSH2_FX_DIR_NOT_EMPTY:
3449 return "Directory not empty";
3451 case LIBSSH2_FX_NOT_A_DIRECTORY:
3452 return "Not a directory";
3454 case LIBSSH2_FX_INVALID_FILENAME:
3455 return "Invalid filename";
3457 case LIBSSH2_FX_LINK_LOOP:
3458 return "Link points to itself";
3460 return "Unknown error in libssh2";
int Curl_debug(struct Curl_easy *data, curl_infotype type, char *ptr, size_t size, struct connectdata *conn)
ssize_t( Curl_recv)(struct connectdata *conn, int sockindex, char *buf, size_t len, CURLcode *err)
CURLcode Curl_urldecode(struct Curl_easy *data, const char *string, size_t length, char **ostring, size_t *olen, bool reject_ctrl)
#define CURLSSH_AUTH_KEYBOARD
void Curl_pgrsSetUploadCounter(struct Curl_easy *data, curl_off_t size)
void Curl_pgrsTime(struct Curl_easy *data, timerid timer)
#define PROTOPT_NOURLQUERY
int stat(const char *path, struct stat *buffer)
char * most_recent_ftp_entrypath
#define CURL_SEEKFUNC_CANTSEEK
struct curl_slist * postquote
const struct Curl_handler * handler
int Curl_pgrsDone(struct connectdata *conn)
UNITTEST_START char * ptr
#define GETSOCK_READSOCK(x)
#define realloc(ptr, size)
#define strcasecompare(a, b)
CURL_EXTERN char * curl_getenv(const char *variable)
curl_sshkeycallback ssh_keyfunc
struct curl_slist * quote
UNITTEST_START int result
struct ssl_config_data ssl
static srvr_sockaddr_union_t from
curl_seek_callback seek_func
int Curl_pgrsUpdate(struct connectdata *conn)
memcpy(filename, filename1, strlen(filename1))
void Curl_setup_transfer(struct connectdata *conn, int sockindex, curl_off_t size, bool getheader, curl_off_t *bytecountp, int writesockindex, curl_off_t *writecountp)
time_t Curl_timeleft(struct Curl_easy *data, struct curltime *nowp, bool duringconnect)
#define CURLSSH_AUTH_PASSWORD
CURLofft curlx_strtoofft(const char *str, char **endp, int base, curl_off_t *num)
#define strncasecompare(a, b, c)
void * Curl_saferealloc(void *ptr, size_t size)
void Curl_pgrsSetUploadSize(struct Curl_easy *data, curl_off_t size)
void Curl_pgrsSetDownloadSize(struct Curl_easy *data, curl_off_t size)
#define CURLSSH_AUTH_PUBLICKEY
CURL_TYPEOF_CURL_OFF_T curl_off_t
#define CLIENTWRITE_HEADER
#define GETSOCK_WRITESOCK(x)
unsigned int curlx_uztoui(size_t uznum)
ssize_t( Curl_send)(struct connectdata *conn, int sockindex, const void *buf, size_t len, CURLcode *err)
CURLcode Curl_speedcheck(struct Curl_easy *data, struct curltime now)
CURLcode Curl_client_write(struct connectdata *conn, int type, char *ptr, size_t len)
#define Curl_safefree(ptr)
curl_socket_t writesockfd
int Curl_socket_check(curl_socket_t readfd0, curl_socket_t readfd1, curl_socket_t writefd, time_t timeout_ms)
#define CURLSSH_AUTH_AGENT
#define CURLSSH_AUTH_HOST
int Curl_single_getsock(const struct connectdata *conn, curl_socket_t *sock, int numsocks)
void Curl_pgrsSetDownloadCounter(struct Curl_easy *data, curl_off_t size)
int(* curl_sshkeycallback)(CURL *easy, const struct curl_khkey *knownkey, const struct curl_khkey *foundkey, enum curl_khmatch, void *clientp)
curl_read_callback fread_func
union connectdata::@34 proto
static CURL * easy[MAX_EASY_HANDLES]
void Curl_expire(struct Curl_easy *data, time_t milli, expire_id id)
#define PROTOPT_CLOSEACTION
size_t curlx_sotouz(curl_off_t sonum)
#define calloc(nbelem, size)
int ftp_create_missing_dirs
#define CURL_FORMAT_CURL_OFF_T