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