1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 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.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 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24
25 #include "curl_setup.h"
26
27 #ifdef USE_WOLFSSH
28
29 #include <limits.h>
30
31 #include <wolfssh/ssh.h>
32 #include <wolfssh/wolfsftp.h>
33 #include "urldata.h"
34 #include "cfilters.h"
35 #include "connect.h"
36 #include "sendf.h"
37 #include "progress.h"
38 #include "curl_path.h"
39 #include "strtoofft.h"
40 #include "transfer.h"
41 #include "speedcheck.h"
42 #include "select.h"
43 #include "multiif.h"
44 #include "warnless.h"
45 #include "strdup.h"
46
47 /* The last 3 #include files should be in this order */
48 #include "curl_printf.h"
49 #include "curl_memory.h"
50 #include "memdebug.h"
51
52 static CURLcode wssh_connect(struct Curl_easy *data, bool *done);
53 static CURLcode wssh_multi_statemach(struct Curl_easy *data, bool *done);
54 static CURLcode wssh_do(struct Curl_easy *data, bool *done);
55 #if 0
56 static CURLcode wscp_done(struct Curl_easy *data,
57 CURLcode, bool premature);
58 static CURLcode wscp_doing(struct Curl_easy *data,
59 bool *dophase_done);
60 static CURLcode wscp_disconnect(struct Curl_easy *data,
61 struct connectdata *conn,
62 bool dead_connection);
63 #endif
64 static CURLcode wsftp_done(struct Curl_easy *data,
65 CURLcode, bool premature);
66 static CURLcode wsftp_doing(struct Curl_easy *data,
67 bool *dophase_done);
68 static CURLcode wsftp_disconnect(struct Curl_easy *data,
69 struct connectdata *conn,
70 bool dead);
71 static int wssh_getsock(struct Curl_easy *data,
72 struct connectdata *conn,
73 curl_socket_t *sock);
74 static CURLcode wssh_setup_connection(struct Curl_easy *data,
75 struct connectdata *conn);
76
77 #if 0
78 /*
79 * SCP protocol handler.
80 */
81
82 const struct Curl_handler Curl_handler_scp = {
83 "SCP", /* scheme */
84 wssh_setup_connection, /* setup_connection */
85 wssh_do, /* do_it */
86 wscp_done, /* done */
87 ZERO_NULL, /* do_more */
88 wssh_connect, /* connect_it */
89 wssh_multi_statemach, /* connecting */
90 wscp_doing, /* doing */
91 wssh_getsock, /* proto_getsock */
92 wssh_getsock, /* doing_getsock */
93 ZERO_NULL, /* domore_getsock */
94 wssh_getsock, /* perform_getsock */
95 wscp_disconnect, /* disconnect */
96 ZERO_NULL, /* write_resp */
97 ZERO_NULL, /* write_resp_hd */
98 ZERO_NULL, /* connection_check */
99 ZERO_NULL, /* attach connection */
100 PORT_SSH, /* defport */
101 CURLPROTO_SCP, /* protocol */
102 PROTOPT_DIRLOCK | PROTOPT_CLOSEACTION
103 | PROTOPT_NOURLQUERY /* flags */
104 };
105
106 #endif
107
108 /*
109 * SFTP protocol handler.
110 */
111
112 const struct Curl_handler Curl_handler_sftp = {
113 "SFTP", /* scheme */
114 wssh_setup_connection, /* setup_connection */
115 wssh_do, /* do_it */
116 wsftp_done, /* done */
117 ZERO_NULL, /* do_more */
118 wssh_connect, /* connect_it */
119 wssh_multi_statemach, /* connecting */
120 wsftp_doing, /* doing */
121 wssh_getsock, /* proto_getsock */
122 wssh_getsock, /* doing_getsock */
123 ZERO_NULL, /* domore_getsock */
124 wssh_getsock, /* perform_getsock */
125 wsftp_disconnect, /* disconnect */
126 ZERO_NULL, /* write_resp */
127 ZERO_NULL, /* write_resp_hd */
128 ZERO_NULL, /* connection_check */
129 ZERO_NULL, /* attach connection */
130 PORT_SSH, /* defport */
131 CURLPROTO_SFTP, /* protocol */
132 CURLPROTO_SFTP, /* family */
133 PROTOPT_DIRLOCK | PROTOPT_CLOSEACTION
134 | PROTOPT_NOURLQUERY /* flags */
135 };
136
137 /*
138 * SSH State machine related code
139 */
140 /* This is the ONLY way to change SSH state! */
state(struct Curl_easy * data,sshstate nowstate)141 static void state(struct Curl_easy *data, sshstate nowstate)
142 {
143 struct connectdata *conn = data->conn;
144 struct ssh_conn *sshc = &conn->proto.sshc;
145 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
146 /* for debug purposes */
147 static const char * const names[] = {
148 "SSH_STOP",
149 "SSH_INIT",
150 "SSH_S_STARTUP",
151 "SSH_HOSTKEY",
152 "SSH_AUTHLIST",
153 "SSH_AUTH_PKEY_INIT",
154 "SSH_AUTH_PKEY",
155 "SSH_AUTH_PASS_INIT",
156 "SSH_AUTH_PASS",
157 "SSH_AUTH_AGENT_INIT",
158 "SSH_AUTH_AGENT_LIST",
159 "SSH_AUTH_AGENT",
160 "SSH_AUTH_HOST_INIT",
161 "SSH_AUTH_HOST",
162 "SSH_AUTH_KEY_INIT",
163 "SSH_AUTH_KEY",
164 "SSH_AUTH_GSSAPI",
165 "SSH_AUTH_DONE",
166 "SSH_SFTP_INIT",
167 "SSH_SFTP_REALPATH",
168 "SSH_SFTP_QUOTE_INIT",
169 "SSH_SFTP_POSTQUOTE_INIT",
170 "SSH_SFTP_QUOTE",
171 "SSH_SFTP_NEXT_QUOTE",
172 "SSH_SFTP_QUOTE_STAT",
173 "SSH_SFTP_QUOTE_SETSTAT",
174 "SSH_SFTP_QUOTE_SYMLINK",
175 "SSH_SFTP_QUOTE_MKDIR",
176 "SSH_SFTP_QUOTE_RENAME",
177 "SSH_SFTP_QUOTE_RMDIR",
178 "SSH_SFTP_QUOTE_UNLINK",
179 "SSH_SFTP_QUOTE_STATVFS",
180 "SSH_SFTP_GETINFO",
181 "SSH_SFTP_FILETIME",
182 "SSH_SFTP_TRANS_INIT",
183 "SSH_SFTP_UPLOAD_INIT",
184 "SSH_SFTP_CREATE_DIRS_INIT",
185 "SSH_SFTP_CREATE_DIRS",
186 "SSH_SFTP_CREATE_DIRS_MKDIR",
187 "SSH_SFTP_READDIR_INIT",
188 "SSH_SFTP_READDIR",
189 "SSH_SFTP_READDIR_LINK",
190 "SSH_SFTP_READDIR_BOTTOM",
191 "SSH_SFTP_READDIR_DONE",
192 "SSH_SFTP_DOWNLOAD_INIT",
193 "SSH_SFTP_DOWNLOAD_STAT",
194 "SSH_SFTP_CLOSE",
195 "SSH_SFTP_SHUTDOWN",
196 "SSH_SCP_TRANS_INIT",
197 "SSH_SCP_UPLOAD_INIT",
198 "SSH_SCP_DOWNLOAD_INIT",
199 "SSH_SCP_DOWNLOAD",
200 "SSH_SCP_DONE",
201 "SSH_SCP_SEND_EOF",
202 "SSH_SCP_WAIT_EOF",
203 "SSH_SCP_WAIT_CLOSE",
204 "SSH_SCP_CHANNEL_FREE",
205 "SSH_SESSION_DISCONNECT",
206 "SSH_SESSION_FREE",
207 "QUIT"
208 };
209
210 /* a precaution to make sure the lists are in sync */
211 DEBUGASSERT(sizeof(names)/sizeof(names[0]) == SSH_LAST);
212
213 if(sshc->state != nowstate) {
214 infof(data, "wolfssh %p state change from %s to %s",
215 (void *)sshc, names[sshc->state], names[nowstate]);
216 }
217 #endif
218
219 sshc->state = nowstate;
220 }
221
wscp_send(struct Curl_easy * data,int sockindex,const void * mem,size_t len,CURLcode * err)222 static ssize_t wscp_send(struct Curl_easy *data, int sockindex,
223 const void *mem, size_t len, CURLcode *err)
224 {
225 ssize_t nwrite = 0;
226 (void)data;
227 (void)sockindex; /* we only support SCP on the fixed known primary socket */
228 (void)mem;
229 (void)len;
230 (void)err;
231
232 return nwrite;
233 }
234
wscp_recv(struct Curl_easy * data,int sockindex,char * mem,size_t len,CURLcode * err)235 static ssize_t wscp_recv(struct Curl_easy *data, int sockindex,
236 char *mem, size_t len, CURLcode *err)
237 {
238 ssize_t nread = 0;
239 (void)data;
240 (void)sockindex; /* we only support SCP on the fixed known primary socket */
241 (void)mem;
242 (void)len;
243 (void)err;
244
245 return nread;
246 }
247
248 /* return number of sent bytes */
wsftp_send(struct Curl_easy * data,int sockindex,const void * mem,size_t len,CURLcode * err)249 static ssize_t wsftp_send(struct Curl_easy *data, int sockindex,
250 const void *mem, size_t len, CURLcode *err)
251 {
252 struct connectdata *conn = data->conn;
253 struct ssh_conn *sshc = &conn->proto.sshc;
254 word32 offset[2];
255 int rc;
256 (void)sockindex;
257
258 offset[0] = (word32)sshc->offset&0xFFFFFFFF;
259 offset[1] = (word32)(sshc->offset>>32)&0xFFFFFFFF;
260
261 rc = wolfSSH_SFTP_SendWritePacket(sshc->ssh_session, sshc->handle,
262 sshc->handleSz,
263 &offset[0],
264 (byte *)mem, (word32)len);
265
266 if(rc == WS_FATAL_ERROR)
267 rc = wolfSSH_get_error(sshc->ssh_session);
268 if(rc == WS_WANT_READ) {
269 conn->waitfor = KEEP_RECV;
270 *err = CURLE_AGAIN;
271 return -1;
272 }
273 else if(rc == WS_WANT_WRITE) {
274 conn->waitfor = KEEP_SEND;
275 *err = CURLE_AGAIN;
276 return -1;
277 }
278 if(rc < 0) {
279 failf(data, "wolfSSH_SFTP_SendWritePacket returned %d", rc);
280 return -1;
281 }
282 DEBUGASSERT(rc == (int)len);
283 infof(data, "sent %zu bytes SFTP from offset %" CURL_FORMAT_CURL_OFF_T,
284 len, sshc->offset);
285 sshc->offset += len;
286 return (ssize_t)rc;
287 }
288
289 /*
290 * Return number of received (decrypted) bytes
291 * or <0 on error
292 */
wsftp_recv(struct Curl_easy * data,int sockindex,char * mem,size_t len,CURLcode * err)293 static ssize_t wsftp_recv(struct Curl_easy *data, int sockindex,
294 char *mem, size_t len, CURLcode *err)
295 {
296 int rc;
297 struct connectdata *conn = data->conn;
298 struct ssh_conn *sshc = &conn->proto.sshc;
299 word32 offset[2];
300 (void)sockindex;
301
302 offset[0] = (word32)sshc->offset&0xFFFFFFFF;
303 offset[1] = (word32)(sshc->offset>>32)&0xFFFFFFFF;
304
305 rc = wolfSSH_SFTP_SendReadPacket(sshc->ssh_session, sshc->handle,
306 sshc->handleSz,
307 &offset[0],
308 (byte *)mem, (word32)len);
309 if(rc == WS_FATAL_ERROR)
310 rc = wolfSSH_get_error(sshc->ssh_session);
311 if(rc == WS_WANT_READ) {
312 conn->waitfor = KEEP_RECV;
313 *err = CURLE_AGAIN;
314 return -1;
315 }
316 else if(rc == WS_WANT_WRITE) {
317 conn->waitfor = KEEP_SEND;
318 *err = CURLE_AGAIN;
319 return -1;
320 }
321
322 DEBUGASSERT(rc <= (int)len);
323
324 if(rc < 0) {
325 failf(data, "wolfSSH_SFTP_SendReadPacket returned %d", rc);
326 return -1;
327 }
328 sshc->offset += len;
329
330 return (ssize_t)rc;
331 }
332
333 /*
334 * SSH setup and connection
335 */
wssh_setup_connection(struct Curl_easy * data,struct connectdata * conn)336 static CURLcode wssh_setup_connection(struct Curl_easy *data,
337 struct connectdata *conn)
338 {
339 struct SSHPROTO *ssh;
340 (void)conn;
341
342 data->req.p.ssh = ssh = calloc(1, sizeof(struct SSHPROTO));
343 if(!ssh)
344 return CURLE_OUT_OF_MEMORY;
345
346 return CURLE_OK;
347 }
348
userauth(byte authtype,WS_UserAuthData * authdata,void * ctx)349 static int userauth(byte authtype,
350 WS_UserAuthData* authdata,
351 void *ctx)
352 {
353 struct Curl_easy *data = ctx;
354 DEBUGF(infof(data, "wolfssh callback: type %s",
355 authtype == WOLFSSH_USERAUTH_PASSWORD ? "PASSWORD" :
356 "PUBLICCKEY"));
357 if(authtype == WOLFSSH_USERAUTH_PASSWORD) {
358 authdata->sf.password.password = (byte *)data->conn->passwd;
359 authdata->sf.password.passwordSz = (word32) strlen(data->conn->passwd);
360 }
361
362 return 0;
363 }
364
wssh_connect(struct Curl_easy * data,bool * done)365 static CURLcode wssh_connect(struct Curl_easy *data, bool *done)
366 {
367 struct connectdata *conn = data->conn;
368 struct ssh_conn *sshc;
369 curl_socket_t sock = conn->sock[FIRSTSOCKET];
370 int rc;
371
372 /* initialize per-handle data if not already */
373 if(!data->req.p.ssh)
374 wssh_setup_connection(data, conn);
375
376 /* We default to persistent connections. We set this already in this connect
377 function to make the reuse checks properly be able to check this bit. */
378 connkeep(conn, "SSH default");
379
380 if(conn->handler->protocol & CURLPROTO_SCP) {
381 conn->recv[FIRSTSOCKET] = wscp_recv;
382 conn->send[FIRSTSOCKET] = wscp_send;
383 }
384 else {
385 conn->recv[FIRSTSOCKET] = wsftp_recv;
386 conn->send[FIRSTSOCKET] = wsftp_send;
387 }
388 sshc = &conn->proto.sshc;
389 sshc->ctx = wolfSSH_CTX_new(WOLFSSH_ENDPOINT_CLIENT, NULL);
390 if(!sshc->ctx) {
391 failf(data, "No wolfSSH context");
392 goto error;
393 }
394
395 sshc->ssh_session = wolfSSH_new(sshc->ctx);
396 if(!sshc->ssh_session) {
397 failf(data, "No wolfSSH session");
398 goto error;
399 }
400
401 rc = wolfSSH_SetUsername(sshc->ssh_session, conn->user);
402 if(rc != WS_SUCCESS) {
403 failf(data, "wolfSSH failed to set user name");
404 goto error;
405 }
406
407 /* set callback for authentication */
408 wolfSSH_SetUserAuth(sshc->ctx, userauth);
409 wolfSSH_SetUserAuthCtx(sshc->ssh_session, data);
410
411 rc = wolfSSH_set_fd(sshc->ssh_session, (int)sock);
412 if(rc) {
413 failf(data, "wolfSSH failed to set socket");
414 goto error;
415 }
416
417 #if 0
418 wolfSSH_Debugging_ON();
419 #endif
420
421 *done = TRUE;
422 if(conn->handler->protocol & CURLPROTO_SCP)
423 state(data, SSH_INIT);
424 else
425 state(data, SSH_SFTP_INIT);
426
427 return wssh_multi_statemach(data, done);
428 error:
429 wolfSSH_free(sshc->ssh_session);
430 wolfSSH_CTX_free(sshc->ctx);
431 return CURLE_FAILED_INIT;
432 }
433
434 /*
435 * wssh_statemach_act() runs the SSH state machine as far as it can without
436 * blocking and without reaching the end. The data the pointer 'block' points
437 * to will be set to TRUE if the wolfssh function returns EAGAIN meaning it
438 * wants to be called again when the socket is ready
439 */
440
wssh_statemach_act(struct Curl_easy * data,bool * block)441 static CURLcode wssh_statemach_act(struct Curl_easy *data, bool *block)
442 {
443 CURLcode result = CURLE_OK;
444 struct connectdata *conn = data->conn;
445 struct ssh_conn *sshc = &conn->proto.sshc;
446 struct SSHPROTO *sftp_scp = data->req.p.ssh;
447 WS_SFTPNAME *name;
448 int rc = 0;
449 *block = FALSE; /* we're not blocking by default */
450
451 do {
452 switch(sshc->state) {
453 case SSH_INIT:
454 state(data, SSH_S_STARTUP);
455 break;
456
457 case SSH_S_STARTUP:
458 rc = wolfSSH_connect(sshc->ssh_session);
459 if(rc != WS_SUCCESS)
460 rc = wolfSSH_get_error(sshc->ssh_session);
461 if(rc == WS_WANT_READ) {
462 *block = TRUE;
463 conn->waitfor = KEEP_RECV;
464 return CURLE_OK;
465 }
466 else if(rc == WS_WANT_WRITE) {
467 *block = TRUE;
468 conn->waitfor = KEEP_SEND;
469 return CURLE_OK;
470 }
471 else if(rc != WS_SUCCESS) {
472 state(data, SSH_STOP);
473 return CURLE_SSH;
474 }
475 infof(data, "wolfssh connected");
476 state(data, SSH_STOP);
477 break;
478 case SSH_STOP:
479 break;
480
481 case SSH_SFTP_INIT:
482 rc = wolfSSH_SFTP_connect(sshc->ssh_session);
483 if(rc != WS_SUCCESS)
484 rc = wolfSSH_get_error(sshc->ssh_session);
485 if(rc == WS_WANT_READ) {
486 *block = TRUE;
487 conn->waitfor = KEEP_RECV;
488 return CURLE_OK;
489 }
490 else if(rc == WS_WANT_WRITE) {
491 *block = TRUE;
492 conn->waitfor = KEEP_SEND;
493 return CURLE_OK;
494 }
495 else if(rc == WS_SUCCESS) {
496 infof(data, "wolfssh SFTP connected");
497 state(data, SSH_SFTP_REALPATH);
498 }
499 else {
500 failf(data, "wolfssh SFTP connect error %d", rc);
501 return CURLE_SSH;
502 }
503 break;
504 case SSH_SFTP_REALPATH:
505 name = wolfSSH_SFTP_RealPath(sshc->ssh_session, (char *)".");
506 rc = wolfSSH_get_error(sshc->ssh_session);
507 if(rc == WS_WANT_READ) {
508 *block = TRUE;
509 conn->waitfor = KEEP_RECV;
510 return CURLE_OK;
511 }
512 else if(rc == WS_WANT_WRITE) {
513 *block = TRUE;
514 conn->waitfor = KEEP_SEND;
515 return CURLE_OK;
516 }
517 else if(name && (rc == WS_SUCCESS)) {
518 sshc->homedir = Curl_memdup0(name->fName, name->fSz);
519 if(!sshc->homedir)
520 sshc->actualcode = CURLE_OUT_OF_MEMORY;
521 wolfSSH_SFTPNAME_list_free(name);
522 state(data, SSH_STOP);
523 return CURLE_OK;
524 }
525 failf(data, "wolfssh SFTP realpath %d", rc);
526 return CURLE_SSH;
527
528 case SSH_SFTP_QUOTE_INIT:
529 result = Curl_getworkingpath(data, sshc->homedir, &sftp_scp->path);
530 if(result) {
531 sshc->actualcode = result;
532 state(data, SSH_STOP);
533 break;
534 }
535
536 if(data->set.quote) {
537 infof(data, "Sending quote commands");
538 sshc->quote_item = data->set.quote;
539 state(data, SSH_SFTP_QUOTE);
540 }
541 else {
542 state(data, SSH_SFTP_GETINFO);
543 }
544 break;
545 case SSH_SFTP_GETINFO:
546 if(data->set.get_filetime) {
547 state(data, SSH_SFTP_FILETIME);
548 }
549 else {
550 state(data, SSH_SFTP_TRANS_INIT);
551 }
552 break;
553 case SSH_SFTP_TRANS_INIT:
554 if(data->state.upload)
555 state(data, SSH_SFTP_UPLOAD_INIT);
556 else {
557 if(sftp_scp->path[strlen(sftp_scp->path)-1] == '/')
558 state(data, SSH_SFTP_READDIR_INIT);
559 else
560 state(data, SSH_SFTP_DOWNLOAD_INIT);
561 }
562 break;
563 case SSH_SFTP_UPLOAD_INIT: {
564 word32 flags;
565 WS_SFTP_FILEATRB createattrs;
566 if(data->state.resume_from) {
567 WS_SFTP_FILEATRB attrs;
568 if(data->state.resume_from < 0) {
569 rc = wolfSSH_SFTP_STAT(sshc->ssh_session, sftp_scp->path,
570 &attrs);
571 if(rc != WS_SUCCESS)
572 break;
573
574 if(rc) {
575 data->state.resume_from = 0;
576 }
577 else {
578 curl_off_t size = ((curl_off_t)attrs.sz[1] << 32) | attrs.sz[0];
579 if(size < 0) {
580 failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size);
581 return CURLE_BAD_DOWNLOAD_RESUME;
582 }
583 data->state.resume_from = size;
584 }
585 }
586 }
587
588 if(data->set.remote_append)
589 /* Try to open for append, but create if nonexisting */
590 flags = WOLFSSH_FXF_WRITE|WOLFSSH_FXF_CREAT|WOLFSSH_FXF_APPEND;
591 else if(data->state.resume_from > 0)
592 /* If we have restart position then open for append */
593 flags = WOLFSSH_FXF_WRITE|WOLFSSH_FXF_APPEND;
594 else
595 /* Clear file before writing (normal behavior) */
596 flags = WOLFSSH_FXF_WRITE|WOLFSSH_FXF_CREAT|WOLFSSH_FXF_TRUNC;
597
598 memset(&createattrs, 0, sizeof(createattrs));
599 createattrs.per = (word32)data->set.new_file_perms;
600 sshc->handleSz = sizeof(sshc->handle);
601 rc = wolfSSH_SFTP_Open(sshc->ssh_session, sftp_scp->path,
602 flags, &createattrs,
603 sshc->handle, &sshc->handleSz);
604 if(rc == WS_FATAL_ERROR)
605 rc = wolfSSH_get_error(sshc->ssh_session);
606 if(rc == WS_WANT_READ) {
607 *block = TRUE;
608 conn->waitfor = KEEP_RECV;
609 return CURLE_OK;
610 }
611 else if(rc == WS_WANT_WRITE) {
612 *block = TRUE;
613 conn->waitfor = KEEP_SEND;
614 return CURLE_OK;
615 }
616 else if(rc == WS_SUCCESS) {
617 infof(data, "wolfssh SFTP open succeeded");
618 }
619 else {
620 failf(data, "wolfssh SFTP upload open failed: %d", rc);
621 return CURLE_SSH;
622 }
623 state(data, SSH_SFTP_DOWNLOAD_STAT);
624
625 /* If we have a restart point then we need to seek to the correct
626 position. */
627 if(data->state.resume_from > 0) {
628 /* Let's read off the proper amount of bytes from the input. */
629 int seekerr = CURL_SEEKFUNC_OK;
630 if(data->set.seek_func) {
631 Curl_set_in_callback(data, true);
632 seekerr = data->set.seek_func(data->set.seek_client,
633 data->state.resume_from, SEEK_SET);
634 Curl_set_in_callback(data, false);
635 }
636
637 if(seekerr != CURL_SEEKFUNC_OK) {
638 curl_off_t passed = 0;
639
640 if(seekerr != CURL_SEEKFUNC_CANTSEEK) {
641 failf(data, "Could not seek stream");
642 return CURLE_FTP_COULDNT_USE_REST;
643 }
644 /* seekerr == CURL_SEEKFUNC_CANTSEEK (can't seek to offset) */
645 do {
646 char scratch[4*1024];
647 size_t readthisamountnow =
648 (data->state.resume_from - passed >
649 (curl_off_t)sizeof(scratch)) ?
650 sizeof(scratch) : curlx_sotouz(data->state.resume_from - passed);
651
652 size_t actuallyread;
653 Curl_set_in_callback(data, true);
654 actuallyread = data->state.fread_func(scratch, 1,
655 readthisamountnow,
656 data->state.in);
657 Curl_set_in_callback(data, false);
658
659 passed += actuallyread;
660 if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
661 /* this checks for greater-than only to make sure that the
662 CURL_READFUNC_ABORT return code still aborts */
663 failf(data, "Failed to read data");
664 return CURLE_FTP_COULDNT_USE_REST;
665 }
666 } while(passed < data->state.resume_from);
667 }
668
669 /* now, decrease the size of the read */
670 if(data->state.infilesize > 0) {
671 data->state.infilesize -= data->state.resume_from;
672 data->req.size = data->state.infilesize;
673 Curl_pgrsSetUploadSize(data, data->state.infilesize);
674 }
675
676 sshc->offset += data->state.resume_from;
677 }
678 if(data->state.infilesize > 0) {
679 data->req.size = data->state.infilesize;
680 Curl_pgrsSetUploadSize(data, data->state.infilesize);
681 }
682 /* upload data */
683 Curl_xfer_setup(data, -1, -1, FALSE, FIRSTSOCKET);
684
685 /* not set by Curl_xfer_setup to preserve keepon bits */
686 conn->sockfd = conn->writesockfd;
687
688 if(result) {
689 state(data, SSH_SFTP_CLOSE);
690 sshc->actualcode = result;
691 }
692 else {
693 /* store this original bitmask setup to use later on if we can't
694 figure out a "real" bitmask */
695 sshc->orig_waitfor = data->req.keepon;
696
697 /* we want to use the _sending_ function even when the socket turns
698 out readable as the underlying libssh2 sftp send function will deal
699 with both accordingly */
700 data->state.select_bits = CURL_CSELECT_OUT;
701
702 /* since we don't really wait for anything at this point, we want the
703 state machine to move on as soon as possible so we set a very short
704 timeout here */
705 Curl_expire(data, 0, EXPIRE_RUN_NOW);
706
707 state(data, SSH_STOP);
708 }
709 break;
710 }
711 case SSH_SFTP_DOWNLOAD_INIT:
712 sshc->handleSz = sizeof(sshc->handle);
713 rc = wolfSSH_SFTP_Open(sshc->ssh_session, sftp_scp->path,
714 WOLFSSH_FXF_READ, NULL,
715 sshc->handle, &sshc->handleSz);
716 if(rc == WS_FATAL_ERROR)
717 rc = wolfSSH_get_error(sshc->ssh_session);
718 if(rc == WS_WANT_READ) {
719 *block = TRUE;
720 conn->waitfor = KEEP_RECV;
721 return CURLE_OK;
722 }
723 else if(rc == WS_WANT_WRITE) {
724 *block = TRUE;
725 conn->waitfor = KEEP_SEND;
726 return CURLE_OK;
727 }
728 else if(rc == WS_SUCCESS) {
729 infof(data, "wolfssh SFTP open succeeded");
730 state(data, SSH_SFTP_DOWNLOAD_STAT);
731 return CURLE_OK;
732 }
733
734 failf(data, "wolfssh SFTP open failed: %d", rc);
735 return CURLE_SSH;
736
737 case SSH_SFTP_DOWNLOAD_STAT: {
738 WS_SFTP_FILEATRB attrs;
739 curl_off_t size;
740
741 rc = wolfSSH_SFTP_STAT(sshc->ssh_session, sftp_scp->path, &attrs);
742 if(rc == WS_FATAL_ERROR)
743 rc = wolfSSH_get_error(sshc->ssh_session);
744 if(rc == WS_WANT_READ) {
745 *block = TRUE;
746 conn->waitfor = KEEP_RECV;
747 return CURLE_OK;
748 }
749 else if(rc == WS_WANT_WRITE) {
750 *block = TRUE;
751 conn->waitfor = KEEP_SEND;
752 return CURLE_OK;
753 }
754 else if(rc == WS_SUCCESS) {
755 infof(data, "wolfssh STAT succeeded");
756 }
757 else {
758 failf(data, "wolfssh SFTP open failed: %d", rc);
759 data->req.size = -1;
760 data->req.maxdownload = -1;
761 Curl_pgrsSetDownloadSize(data, -1);
762 return CURLE_SSH;
763 }
764
765 size = ((curl_off_t)attrs.sz[1] <<32) | attrs.sz[0];
766
767 data->req.size = size;
768 data->req.maxdownload = size;
769 Curl_pgrsSetDownloadSize(data, size);
770
771 infof(data, "SFTP download %" CURL_FORMAT_CURL_OFF_T " bytes", size);
772
773 /* We cannot seek with wolfSSH so resuming and range requests are not
774 possible */
775 if(data->state.use_range || data->state.resume_from) {
776 infof(data, "wolfSSH cannot do range/seek on SFTP");
777 return CURLE_BAD_DOWNLOAD_RESUME;
778 }
779
780 /* Setup the actual download */
781 if(data->req.size == 0) {
782 /* no data to transfer */
783 Curl_xfer_setup(data, -1, -1, FALSE, -1);
784 infof(data, "File already completely downloaded");
785 state(data, SSH_STOP);
786 break;
787 }
788 Curl_xfer_setup(data, FIRSTSOCKET, data->req.size, FALSE, -1);
789
790 /* not set by Curl_xfer_setup to preserve keepon bits */
791 conn->writesockfd = conn->sockfd;
792
793 /* we want to use the _receiving_ function even when the socket turns
794 out writableable as the underlying libssh2 recv function will deal
795 with both accordingly */
796 data->state.select_bits = CURL_CSELECT_IN;
797
798 if(result) {
799 /* this should never occur; the close state should be entered
800 at the time the error occurs */
801 state(data, SSH_SFTP_CLOSE);
802 sshc->actualcode = result;
803 }
804 else {
805 state(data, SSH_STOP);
806 }
807 break;
808 }
809 case SSH_SFTP_CLOSE:
810 if(sshc->handleSz)
811 rc = wolfSSH_SFTP_Close(sshc->ssh_session, sshc->handle,
812 sshc->handleSz);
813 else
814 rc = WS_SUCCESS; /* directory listing */
815 if(rc == WS_WANT_READ) {
816 *block = TRUE;
817 conn->waitfor = KEEP_RECV;
818 return CURLE_OK;
819 }
820 else if(rc == WS_WANT_WRITE) {
821 *block = TRUE;
822 conn->waitfor = KEEP_SEND;
823 return CURLE_OK;
824 }
825 else if(rc == WS_SUCCESS) {
826 state(data, SSH_STOP);
827 return CURLE_OK;
828 }
829
830 failf(data, "wolfssh SFTP CLOSE failed: %d", rc);
831 return CURLE_SSH;
832
833 case SSH_SFTP_READDIR_INIT:
834 Curl_pgrsSetDownloadSize(data, -1);
835 if(data->req.no_body) {
836 state(data, SSH_STOP);
837 break;
838 }
839 state(data, SSH_SFTP_READDIR);
840 break;
841
842 case SSH_SFTP_READDIR:
843 name = wolfSSH_SFTP_LS(sshc->ssh_session, sftp_scp->path);
844 if(!name)
845 rc = wolfSSH_get_error(sshc->ssh_session);
846 else
847 rc = WS_SUCCESS;
848
849 if(rc == WS_WANT_READ) {
850 *block = TRUE;
851 conn->waitfor = KEEP_RECV;
852 return CURLE_OK;
853 }
854 else if(rc == WS_WANT_WRITE) {
855 *block = TRUE;
856 conn->waitfor = KEEP_SEND;
857 return CURLE_OK;
858 }
859 else if(name && (rc == WS_SUCCESS)) {
860 WS_SFTPNAME *origname = name;
861 result = CURLE_OK;
862 while(name) {
863 char *line = aprintf("%s\n",
864 data->set.list_only ?
865 name->fName : name->lName);
866 if(!line) {
867 state(data, SSH_SFTP_CLOSE);
868 sshc->actualcode = CURLE_OUT_OF_MEMORY;
869 break;
870 }
871 result = Curl_client_write(data, CLIENTWRITE_BODY,
872 line, strlen(line));
873 free(line);
874 if(result) {
875 sshc->actualcode = result;
876 break;
877 }
878 name = name->next;
879 }
880 wolfSSH_SFTPNAME_list_free(origname);
881 state(data, SSH_STOP);
882 return result;
883 }
884 failf(data, "wolfssh SFTP ls failed: %d", rc);
885 return CURLE_SSH;
886
887 case SSH_SFTP_SHUTDOWN:
888 Curl_safefree(sshc->homedir);
889 wolfSSH_free(sshc->ssh_session);
890 wolfSSH_CTX_free(sshc->ctx);
891 state(data, SSH_STOP);
892 return CURLE_OK;
893 default:
894 break;
895 }
896 } while(!rc && (sshc->state != SSH_STOP));
897 return result;
898 }
899
900 /* called repeatedly until done from multi.c */
wssh_multi_statemach(struct Curl_easy * data,bool * done)901 static CURLcode wssh_multi_statemach(struct Curl_easy *data, bool *done)
902 {
903 struct connectdata *conn = data->conn;
904 struct ssh_conn *sshc = &conn->proto.sshc;
905 CURLcode result = CURLE_OK;
906 bool block; /* we store the status and use that to provide a ssh_getsock()
907 implementation */
908 do {
909 result = wssh_statemach_act(data, &block);
910 *done = (sshc->state == SSH_STOP) ? TRUE : FALSE;
911 /* if there's no error, it isn't done and it didn't EWOULDBLOCK, then
912 try again */
913 if(*done) {
914 DEBUGF(infof(data, "wssh_statemach_act says DONE"));
915 }
916 } while(!result && !*done && !block);
917
918 return result;
919 }
920
921 static
wscp_perform(struct Curl_easy * data,bool * connected,bool * dophase_done)922 CURLcode wscp_perform(struct Curl_easy *data,
923 bool *connected,
924 bool *dophase_done)
925 {
926 (void)data;
927 (void)connected;
928 (void)dophase_done;
929 return CURLE_OK;
930 }
931
932 static
wsftp_perform(struct Curl_easy * data,bool * connected,bool * dophase_done)933 CURLcode wsftp_perform(struct Curl_easy *data,
934 bool *connected,
935 bool *dophase_done)
936 {
937 CURLcode result = CURLE_OK;
938
939 DEBUGF(infof(data, "DO phase starts"));
940
941 *dophase_done = FALSE; /* not done yet */
942
943 /* start the first command in the DO phase */
944 state(data, SSH_SFTP_QUOTE_INIT);
945
946 /* run the state-machine */
947 result = wssh_multi_statemach(data, dophase_done);
948
949 *connected = Curl_conn_is_connected(data->conn, FIRSTSOCKET);
950
951 if(*dophase_done) {
952 DEBUGF(infof(data, "DO phase is complete"));
953 }
954
955 return result;
956 }
957
958 /*
959 * The DO function is generic for both protocols.
960 */
wssh_do(struct Curl_easy * data,bool * done)961 static CURLcode wssh_do(struct Curl_easy *data, bool *done)
962 {
963 CURLcode result;
964 bool connected = 0;
965 struct connectdata *conn = data->conn;
966 struct ssh_conn *sshc = &conn->proto.sshc;
967
968 *done = FALSE; /* default to false */
969 data->req.size = -1; /* make sure this is unknown at this point */
970 sshc->actualcode = CURLE_OK; /* reset error code */
971 sshc->secondCreateDirs = 0; /* reset the create dir attempt state
972 variable */
973
974 Curl_pgrsSetUploadCounter(data, 0);
975 Curl_pgrsSetDownloadCounter(data, 0);
976 Curl_pgrsSetUploadSize(data, -1);
977 Curl_pgrsSetDownloadSize(data, -1);
978
979 if(conn->handler->protocol & CURLPROTO_SCP)
980 result = wscp_perform(data, &connected, done);
981 else
982 result = wsftp_perform(data, &connected, done);
983
984 return result;
985 }
986
wssh_block_statemach(struct Curl_easy * data,bool disconnect)987 static CURLcode wssh_block_statemach(struct Curl_easy *data,
988 bool disconnect)
989 {
990 struct connectdata *conn = data->conn;
991 struct ssh_conn *sshc = &conn->proto.sshc;
992 CURLcode result = CURLE_OK;
993
994 while((sshc->state != SSH_STOP) && !result) {
995 bool block;
996 timediff_t left = 1000;
997 struct curltime now = Curl_now();
998
999 result = wssh_statemach_act(data, &block);
1000 if(result)
1001 break;
1002
1003 if(!disconnect) {
1004 if(Curl_pgrsUpdate(data))
1005 return CURLE_ABORTED_BY_CALLBACK;
1006
1007 result = Curl_speedcheck(data, now);
1008 if(result)
1009 break;
1010
1011 left = Curl_timeleft(data, NULL, FALSE);
1012 if(left < 0) {
1013 failf(data, "Operation timed out");
1014 return CURLE_OPERATION_TIMEDOUT;
1015 }
1016 }
1017
1018 if(!result) {
1019 int dir = conn->waitfor;
1020 curl_socket_t sock = conn->sock[FIRSTSOCKET];
1021 curl_socket_t fd_read = CURL_SOCKET_BAD;
1022 curl_socket_t fd_write = CURL_SOCKET_BAD;
1023 if(dir == KEEP_RECV)
1024 fd_read = sock;
1025 else if(dir == KEEP_SEND)
1026 fd_write = sock;
1027
1028 /* wait for the socket to become ready */
1029 (void)Curl_socket_check(fd_read, CURL_SOCKET_BAD, fd_write,
1030 left>1000?1000:left); /* ignore result */
1031 }
1032 }
1033
1034 return result;
1035 }
1036
1037 /* generic done function for both SCP and SFTP called from their specific
1038 done functions */
wssh_done(struct Curl_easy * data,CURLcode status)1039 static CURLcode wssh_done(struct Curl_easy *data, CURLcode status)
1040 {
1041 CURLcode result = CURLE_OK;
1042 struct SSHPROTO *sftp_scp = data->req.p.ssh;
1043
1044 if(!status) {
1045 /* run the state-machine */
1046 result = wssh_block_statemach(data, FALSE);
1047 }
1048 else
1049 result = status;
1050
1051 if(sftp_scp)
1052 Curl_safefree(sftp_scp->path);
1053 if(Curl_pgrsDone(data))
1054 return CURLE_ABORTED_BY_CALLBACK;
1055
1056 data->req.keepon = 0; /* clear all bits */
1057 return result;
1058 }
1059
1060 #if 0
1061 static CURLcode wscp_done(struct Curl_easy *data,
1062 CURLcode code, bool premature)
1063 {
1064 CURLcode result = CURLE_OK;
1065 (void)conn;
1066 (void)code;
1067 (void)premature;
1068
1069 return result;
1070 }
1071
1072 static CURLcode wscp_doing(struct Curl_easy *data,
1073 bool *dophase_done)
1074 {
1075 CURLcode result = CURLE_OK;
1076 (void)conn;
1077 (void)dophase_done;
1078
1079 return result;
1080 }
1081
1082 static CURLcode wscp_disconnect(struct Curl_easy *data,
1083 struct connectdata *conn, bool dead_connection)
1084 {
1085 CURLcode result = CURLE_OK;
1086 (void)data;
1087 (void)conn;
1088 (void)dead_connection;
1089
1090 return result;
1091 }
1092 #endif
1093
wsftp_done(struct Curl_easy * data,CURLcode code,bool premature)1094 static CURLcode wsftp_done(struct Curl_easy *data,
1095 CURLcode code, bool premature)
1096 {
1097 (void)premature;
1098 state(data, SSH_SFTP_CLOSE);
1099
1100 return wssh_done(data, code);
1101 }
1102
wsftp_doing(struct Curl_easy * data,bool * dophase_done)1103 static CURLcode wsftp_doing(struct Curl_easy *data,
1104 bool *dophase_done)
1105 {
1106 CURLcode result = wssh_multi_statemach(data, dophase_done);
1107
1108 if(*dophase_done) {
1109 DEBUGF(infof(data, "DO phase is complete"));
1110 }
1111 return result;
1112 }
1113
wsftp_disconnect(struct Curl_easy * data,struct connectdata * conn,bool dead)1114 static CURLcode wsftp_disconnect(struct Curl_easy *data,
1115 struct connectdata *conn,
1116 bool dead)
1117 {
1118 CURLcode result = CURLE_OK;
1119 (void)dead;
1120
1121 DEBUGF(infof(data, "SSH DISCONNECT starts now"));
1122
1123 if(conn->proto.sshc.ssh_session) {
1124 /* only if there's a session still around to use! */
1125 state(data, SSH_SFTP_SHUTDOWN);
1126 result = wssh_block_statemach(data, TRUE);
1127 }
1128
1129 DEBUGF(infof(data, "SSH DISCONNECT is done"));
1130 return result;
1131 }
1132
wssh_getsock(struct Curl_easy * data,struct connectdata * conn,curl_socket_t * sock)1133 static int wssh_getsock(struct Curl_easy *data,
1134 struct connectdata *conn,
1135 curl_socket_t *sock)
1136 {
1137 int bitmap = GETSOCK_BLANK;
1138 int dir = conn->waitfor;
1139 (void)data;
1140 sock[0] = conn->sock[FIRSTSOCKET];
1141
1142 if(dir == KEEP_RECV)
1143 bitmap |= GETSOCK_READSOCK(FIRSTSOCKET);
1144 else if(dir == KEEP_SEND)
1145 bitmap |= GETSOCK_WRITESOCK(FIRSTSOCKET);
1146
1147 return bitmap;
1148 }
1149
Curl_ssh_version(char * buffer,size_t buflen)1150 void Curl_ssh_version(char *buffer, size_t buflen)
1151 {
1152 (void)msnprintf(buffer, buflen, "wolfssh/%s", LIBWOLFSSH_VERSION_STRING);
1153 }
1154
Curl_ssh_init(void)1155 CURLcode Curl_ssh_init(void)
1156 {
1157 if(WS_SUCCESS != wolfSSH_Init()) {
1158 DEBUGF(fprintf(stderr, "Error: wolfSSH_Init failed\n"));
1159 return CURLE_FAILED_INIT;
1160 }
1161
1162 return CURLE_OK;
1163 }
Curl_ssh_cleanup(void)1164 void Curl_ssh_cleanup(void)
1165 {
1166 (void)wolfSSH_Cleanup();
1167 }
1168
1169 #endif /* USE_WOLFSSH */
1170
