]>
Commit | Line | Data |
---|---|---|
0a12ec87 RJ |
1 | /* |
2 | * Secure Shell (ssh) backend for QEMU. | |
3 | * | |
4 | * Copyright (C) 2013 Red Hat Inc., Richard W.M. Jones <rjones@redhat.com> | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
24 | ||
80c71a24 | 25 | #include "qemu/osdep.h" |
0a12ec87 RJ |
26 | |
27 | #include <libssh2.h> | |
28 | #include <libssh2_sftp.h> | |
29 | ||
30 | #include "block/block_int.h" | |
da34e65c | 31 | #include "qapi/error.h" |
d49b6836 | 32 | #include "qemu/error-report.h" |
0da5b8ef | 33 | #include "qemu/cutils.h" |
0a12ec87 RJ |
34 | #include "qemu/sockets.h" |
35 | #include "qemu/uri.h" | |
0da5b8ef | 36 | #include "qapi-visit.h" |
d49b6836 | 37 | #include "qapi/qmp/qstring.h" |
0da5b8ef AA |
38 | #include "qapi/qobject-input-visitor.h" |
39 | #include "qapi/qobject-output-visitor.h" | |
0a12ec87 RJ |
40 | |
41 | /* DEBUG_SSH=1 enables the DPRINTF (debugging printf) statements in | |
42 | * this block driver code. | |
43 | * | |
44 | * TRACE_LIBSSH2=<bitmask> enables tracing in libssh2 itself. Note | |
45 | * that this requires that libssh2 was specially compiled with the | |
46 | * `./configure --enable-debug' option, so most likely you will have | |
47 | * to compile it yourself. The meaning of <bitmask> is described | |
48 | * here: http://www.libssh2.org/libssh2_trace.html | |
49 | */ | |
50 | #define DEBUG_SSH 0 | |
51 | #define TRACE_LIBSSH2 0 /* or try: LIBSSH2_TRACE_SFTP */ | |
52 | ||
53 | #define DPRINTF(fmt, ...) \ | |
54 | do { \ | |
55 | if (DEBUG_SSH) { \ | |
56 | fprintf(stderr, "ssh: %-15s " fmt "\n", \ | |
57 | __func__, ##__VA_ARGS__); \ | |
58 | } \ | |
59 | } while (0) | |
60 | ||
61 | typedef struct BDRVSSHState { | |
62 | /* Coroutine. */ | |
63 | CoMutex lock; | |
64 | ||
65 | /* SSH connection. */ | |
66 | int sock; /* socket */ | |
67 | LIBSSH2_SESSION *session; /* ssh session */ | |
68 | LIBSSH2_SFTP *sftp; /* sftp session */ | |
69 | LIBSSH2_SFTP_HANDLE *sftp_handle; /* sftp remote file handle */ | |
70 | ||
71 | /* See ssh_seek() function below. */ | |
72 | int64_t offset; | |
73 | bool offset_op_read; | |
74 | ||
75 | /* File attributes at open. We try to keep the .filesize field | |
76 | * updated if it changes (eg by writing at the end of the file). | |
77 | */ | |
78 | LIBSSH2_SFTP_ATTRIBUTES attrs; | |
9a2d462e | 79 | |
0da5b8ef AA |
80 | InetSocketAddress *inet; |
81 | ||
9a2d462e | 82 | /* Used to warn if 'flush' is not supported. */ |
9a2d462e | 83 | bool unsafe_flush_warning; |
0a12ec87 RJ |
84 | } BDRVSSHState; |
85 | ||
86 | static void ssh_state_init(BDRVSSHState *s) | |
87 | { | |
88 | memset(s, 0, sizeof *s); | |
89 | s->sock = -1; | |
90 | s->offset = -1; | |
91 | qemu_co_mutex_init(&s->lock); | |
92 | } | |
93 | ||
94 | static void ssh_state_free(BDRVSSHState *s) | |
95 | { | |
96 | if (s->sftp_handle) { | |
97 | libssh2_sftp_close(s->sftp_handle); | |
98 | } | |
99 | if (s->sftp) { | |
100 | libssh2_sftp_shutdown(s->sftp); | |
101 | } | |
102 | if (s->session) { | |
103 | libssh2_session_disconnect(s->session, | |
104 | "from qemu ssh client: " | |
105 | "user closed the connection"); | |
106 | libssh2_session_free(s->session); | |
107 | } | |
108 | if (s->sock >= 0) { | |
109 | close(s->sock); | |
110 | } | |
111 | } | |
112 | ||
01c2b265 MA |
113 | static void GCC_FMT_ATTR(3, 4) |
114 | session_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...) | |
115 | { | |
116 | va_list args; | |
117 | char *msg; | |
118 | ||
119 | va_start(args, fs); | |
120 | msg = g_strdup_vprintf(fs, args); | |
121 | va_end(args); | |
122 | ||
123 | if (s->session) { | |
124 | char *ssh_err; | |
125 | int ssh_err_code; | |
126 | ||
127 | /* This is not an errno. See <libssh2.h>. */ | |
128 | ssh_err_code = libssh2_session_last_error(s->session, | |
129 | &ssh_err, NULL, 0); | |
130 | error_setg(errp, "%s: %s (libssh2 error code: %d)", | |
131 | msg, ssh_err, ssh_err_code); | |
132 | } else { | |
133 | error_setg(errp, "%s", msg); | |
134 | } | |
135 | g_free(msg); | |
136 | } | |
137 | ||
5496fb1a MA |
138 | static void GCC_FMT_ATTR(3, 4) |
139 | sftp_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...) | |
0a12ec87 RJ |
140 | { |
141 | va_list args; | |
5496fb1a | 142 | char *msg; |
0a12ec87 RJ |
143 | |
144 | va_start(args, fs); | |
5496fb1a MA |
145 | msg = g_strdup_vprintf(fs, args); |
146 | va_end(args); | |
0a12ec87 | 147 | |
5496fb1a | 148 | if (s->sftp) { |
0a12ec87 RJ |
149 | char *ssh_err; |
150 | int ssh_err_code; | |
5496fb1a | 151 | unsigned long sftp_err_code; |
0a12ec87 | 152 | |
0a12ec87 | 153 | /* This is not an errno. See <libssh2.h>. */ |
04bc7c0e MA |
154 | ssh_err_code = libssh2_session_last_error(s->session, |
155 | &ssh_err, NULL, 0); | |
5496fb1a MA |
156 | /* See <libssh2_sftp.h>. */ |
157 | sftp_err_code = libssh2_sftp_last_error((s)->sftp); | |
0a12ec87 | 158 | |
5496fb1a MA |
159 | error_setg(errp, |
160 | "%s: %s (libssh2 error code: %d, sftp error code: %lu)", | |
161 | msg, ssh_err, ssh_err_code, sftp_err_code); | |
162 | } else { | |
163 | error_setg(errp, "%s", msg); | |
164 | } | |
165 | g_free(msg); | |
0a12ec87 RJ |
166 | } |
167 | ||
6ae7d660 | 168 | static void GCC_FMT_ATTR(2, 3) |
0a12ec87 RJ |
169 | sftp_error_report(BDRVSSHState *s, const char *fs, ...) |
170 | { | |
171 | va_list args; | |
172 | ||
173 | va_start(args, fs); | |
174 | error_vprintf(fs, args); | |
175 | ||
176 | if ((s)->sftp) { | |
177 | char *ssh_err; | |
178 | int ssh_err_code; | |
179 | unsigned long sftp_err_code; | |
180 | ||
0a12ec87 | 181 | /* This is not an errno. See <libssh2.h>. */ |
04bc7c0e MA |
182 | ssh_err_code = libssh2_session_last_error(s->session, |
183 | &ssh_err, NULL, 0); | |
0a12ec87 RJ |
184 | /* See <libssh2_sftp.h>. */ |
185 | sftp_err_code = libssh2_sftp_last_error((s)->sftp); | |
186 | ||
187 | error_printf(": %s (libssh2 error code: %d, sftp error code: %lu)", | |
188 | ssh_err, ssh_err_code, sftp_err_code); | |
189 | } | |
190 | ||
191 | va_end(args); | |
192 | error_printf("\n"); | |
193 | } | |
194 | ||
195 | static int parse_uri(const char *filename, QDict *options, Error **errp) | |
196 | { | |
197 | URI *uri = NULL; | |
eab2ac9d | 198 | QueryParams *qp; |
1059f1bb | 199 | char *port_str; |
0a12ec87 RJ |
200 | int i; |
201 | ||
202 | uri = uri_parse(filename); | |
203 | if (!uri) { | |
204 | return -EINVAL; | |
205 | } | |
206 | ||
f69165a8 | 207 | if (g_strcmp0(uri->scheme, "ssh") != 0) { |
0a12ec87 RJ |
208 | error_setg(errp, "URI scheme must be 'ssh'"); |
209 | goto err; | |
210 | } | |
211 | ||
212 | if (!uri->server || strcmp(uri->server, "") == 0) { | |
213 | error_setg(errp, "missing hostname in URI"); | |
214 | goto err; | |
215 | } | |
216 | ||
217 | if (!uri->path || strcmp(uri->path, "") == 0) { | |
218 | error_setg(errp, "missing remote path in URI"); | |
219 | goto err; | |
220 | } | |
221 | ||
222 | qp = query_params_parse(uri->query); | |
223 | if (!qp) { | |
224 | error_setg(errp, "could not parse query parameters"); | |
225 | goto err; | |
226 | } | |
227 | ||
228 | if(uri->user && strcmp(uri->user, "") != 0) { | |
46f5ac20 | 229 | qdict_put_str(options, "user", uri->user); |
0a12ec87 RJ |
230 | } |
231 | ||
46f5ac20 | 232 | qdict_put_str(options, "server.host", uri->server); |
0a12ec87 | 233 | |
1059f1bb | 234 | port_str = g_strdup_printf("%d", uri->port ?: 22); |
46f5ac20 | 235 | qdict_put_str(options, "server.port", port_str); |
1059f1bb | 236 | g_free(port_str); |
0a12ec87 | 237 | |
46f5ac20 | 238 | qdict_put_str(options, "path", uri->path); |
0a12ec87 RJ |
239 | |
240 | /* Pick out any query parameters that we understand, and ignore | |
241 | * the rest. | |
242 | */ | |
243 | for (i = 0; i < qp->n; ++i) { | |
244 | if (strcmp(qp->p[i].name, "host_key_check") == 0) { | |
46f5ac20 | 245 | qdict_put_str(options, "host_key_check", qp->p[i].value); |
0a12ec87 RJ |
246 | } |
247 | } | |
248 | ||
249 | query_params_free(qp); | |
250 | uri_free(uri); | |
251 | return 0; | |
252 | ||
253 | err: | |
0a12ec87 RJ |
254 | if (uri) { |
255 | uri_free(uri); | |
256 | } | |
257 | return -EINVAL; | |
258 | } | |
259 | ||
89dbe180 AA |
260 | static bool ssh_has_filename_options_conflict(QDict *options, Error **errp) |
261 | { | |
262 | const QDictEntry *qe; | |
263 | ||
264 | for (qe = qdict_first(options); qe; qe = qdict_next(options, qe)) { | |
265 | if (!strcmp(qe->key, "host") || | |
266 | !strcmp(qe->key, "port") || | |
267 | !strcmp(qe->key, "path") || | |
268 | !strcmp(qe->key, "user") || | |
0da5b8ef AA |
269 | !strcmp(qe->key, "host_key_check") || |
270 | strstart(qe->key, "server.", NULL)) | |
89dbe180 AA |
271 | { |
272 | error_setg(errp, "Option '%s' cannot be used with a file name", | |
273 | qe->key); | |
274 | return true; | |
275 | } | |
276 | } | |
277 | ||
278 | return false; | |
279 | } | |
280 | ||
0a12ec87 RJ |
281 | static void ssh_parse_filename(const char *filename, QDict *options, |
282 | Error **errp) | |
283 | { | |
89dbe180 | 284 | if (ssh_has_filename_options_conflict(options, errp)) { |
0a12ec87 RJ |
285 | return; |
286 | } | |
287 | ||
288 | parse_uri(filename, options, errp); | |
289 | } | |
290 | ||
291 | static int check_host_key_knownhosts(BDRVSSHState *s, | |
01c2b265 | 292 | const char *host, int port, Error **errp) |
0a12ec87 RJ |
293 | { |
294 | const char *home; | |
295 | char *knh_file = NULL; | |
296 | LIBSSH2_KNOWNHOSTS *knh = NULL; | |
297 | struct libssh2_knownhost *found; | |
298 | int ret, r; | |
299 | const char *hostkey; | |
300 | size_t len; | |
301 | int type; | |
302 | ||
303 | hostkey = libssh2_session_hostkey(s->session, &len, &type); | |
304 | if (!hostkey) { | |
305 | ret = -EINVAL; | |
01c2b265 | 306 | session_error_setg(errp, s, "failed to read remote host key"); |
0a12ec87 RJ |
307 | goto out; |
308 | } | |
309 | ||
310 | knh = libssh2_knownhost_init(s->session); | |
311 | if (!knh) { | |
312 | ret = -EINVAL; | |
01c2b265 MA |
313 | session_error_setg(errp, s, |
314 | "failed to initialize known hosts support"); | |
0a12ec87 RJ |
315 | goto out; |
316 | } | |
317 | ||
318 | home = getenv("HOME"); | |
319 | if (home) { | |
320 | knh_file = g_strdup_printf("%s/.ssh/known_hosts", home); | |
321 | } else { | |
322 | knh_file = g_strdup_printf("/root/.ssh/known_hosts"); | |
323 | } | |
324 | ||
325 | /* Read all known hosts from OpenSSH-style known_hosts file. */ | |
326 | libssh2_knownhost_readfile(knh, knh_file, LIBSSH2_KNOWNHOST_FILE_OPENSSH); | |
327 | ||
328 | r = libssh2_knownhost_checkp(knh, host, port, hostkey, len, | |
329 | LIBSSH2_KNOWNHOST_TYPE_PLAIN| | |
330 | LIBSSH2_KNOWNHOST_KEYENC_RAW, | |
331 | &found); | |
332 | switch (r) { | |
333 | case LIBSSH2_KNOWNHOST_CHECK_MATCH: | |
334 | /* OK */ | |
335 | DPRINTF("host key OK: %s", found->key); | |
336 | break; | |
337 | case LIBSSH2_KNOWNHOST_CHECK_MISMATCH: | |
338 | ret = -EINVAL; | |
01c2b265 MA |
339 | session_error_setg(errp, s, |
340 | "host key does not match the one in known_hosts" | |
341 | " (found key %s)", found->key); | |
0a12ec87 RJ |
342 | goto out; |
343 | case LIBSSH2_KNOWNHOST_CHECK_NOTFOUND: | |
344 | ret = -EINVAL; | |
01c2b265 | 345 | session_error_setg(errp, s, "no host key was found in known_hosts"); |
0a12ec87 RJ |
346 | goto out; |
347 | case LIBSSH2_KNOWNHOST_CHECK_FAILURE: | |
348 | ret = -EINVAL; | |
01c2b265 MA |
349 | session_error_setg(errp, s, |
350 | "failure matching the host key with known_hosts"); | |
0a12ec87 RJ |
351 | goto out; |
352 | default: | |
353 | ret = -EINVAL; | |
01c2b265 MA |
354 | session_error_setg(errp, s, "unknown error matching the host key" |
355 | " with known_hosts (%d)", r); | |
0a12ec87 RJ |
356 | goto out; |
357 | } | |
358 | ||
359 | /* known_hosts checking successful. */ | |
360 | ret = 0; | |
361 | ||
362 | out: | |
363 | if (knh != NULL) { | |
364 | libssh2_knownhost_free(knh); | |
365 | } | |
366 | g_free(knh_file); | |
367 | return ret; | |
368 | } | |
369 | ||
370 | static unsigned hex2decimal(char ch) | |
371 | { | |
372 | if (ch >= '0' && ch <= '9') { | |
373 | return (ch - '0'); | |
374 | } else if (ch >= 'a' && ch <= 'f') { | |
375 | return 10 + (ch - 'a'); | |
376 | } else if (ch >= 'A' && ch <= 'F') { | |
377 | return 10 + (ch - 'A'); | |
378 | } | |
379 | ||
380 | return -1; | |
381 | } | |
382 | ||
383 | /* Compare the binary fingerprint (hash of host key) with the | |
384 | * host_key_check parameter. | |
385 | */ | |
386 | static int compare_fingerprint(const unsigned char *fingerprint, size_t len, | |
387 | const char *host_key_check) | |
388 | { | |
389 | unsigned c; | |
390 | ||
391 | while (len > 0) { | |
392 | while (*host_key_check == ':') | |
393 | host_key_check++; | |
394 | if (!qemu_isxdigit(host_key_check[0]) || | |
395 | !qemu_isxdigit(host_key_check[1])) | |
396 | return 1; | |
397 | c = hex2decimal(host_key_check[0]) * 16 + | |
398 | hex2decimal(host_key_check[1]); | |
399 | if (c - *fingerprint != 0) | |
400 | return c - *fingerprint; | |
401 | fingerprint++; | |
402 | len--; | |
403 | host_key_check += 2; | |
404 | } | |
405 | return *host_key_check - '\0'; | |
406 | } | |
407 | ||
408 | static int | |
409 | check_host_key_hash(BDRVSSHState *s, const char *hash, | |
01c2b265 | 410 | int hash_type, size_t fingerprint_len, Error **errp) |
0a12ec87 RJ |
411 | { |
412 | const char *fingerprint; | |
413 | ||
414 | fingerprint = libssh2_hostkey_hash(s->session, hash_type); | |
415 | if (!fingerprint) { | |
01c2b265 | 416 | session_error_setg(errp, s, "failed to read remote host key"); |
0a12ec87 RJ |
417 | return -EINVAL; |
418 | } | |
419 | ||
420 | if(compare_fingerprint((unsigned char *) fingerprint, fingerprint_len, | |
421 | hash) != 0) { | |
01c2b265 MA |
422 | error_setg(errp, "remote host key does not match host_key_check '%s'", |
423 | hash); | |
0a12ec87 RJ |
424 | return -EPERM; |
425 | } | |
426 | ||
427 | return 0; | |
428 | } | |
429 | ||
430 | static int check_host_key(BDRVSSHState *s, const char *host, int port, | |
01c2b265 | 431 | const char *host_key_check, Error **errp) |
0a12ec87 RJ |
432 | { |
433 | /* host_key_check=no */ | |
434 | if (strcmp(host_key_check, "no") == 0) { | |
435 | return 0; | |
436 | } | |
437 | ||
438 | /* host_key_check=md5:xx:yy:zz:... */ | |
c7a101f5 | 439 | if (strncmp(host_key_check, "md5:", 4) == 0) { |
0a12ec87 | 440 | return check_host_key_hash(s, &host_key_check[4], |
01c2b265 | 441 | LIBSSH2_HOSTKEY_HASH_MD5, 16, errp); |
0a12ec87 RJ |
442 | } |
443 | ||
444 | /* host_key_check=sha1:xx:yy:zz:... */ | |
c7a101f5 | 445 | if (strncmp(host_key_check, "sha1:", 5) == 0) { |
0a12ec87 | 446 | return check_host_key_hash(s, &host_key_check[5], |
01c2b265 | 447 | LIBSSH2_HOSTKEY_HASH_SHA1, 20, errp); |
0a12ec87 RJ |
448 | } |
449 | ||
450 | /* host_key_check=yes */ | |
451 | if (strcmp(host_key_check, "yes") == 0) { | |
01c2b265 | 452 | return check_host_key_knownhosts(s, host, port, errp); |
0a12ec87 RJ |
453 | } |
454 | ||
01c2b265 | 455 | error_setg(errp, "unknown host_key_check setting (%s)", host_key_check); |
0a12ec87 RJ |
456 | return -EINVAL; |
457 | } | |
458 | ||
4618e658 | 459 | static int authenticate(BDRVSSHState *s, const char *user, Error **errp) |
0a12ec87 RJ |
460 | { |
461 | int r, ret; | |
462 | const char *userauthlist; | |
463 | LIBSSH2_AGENT *agent = NULL; | |
464 | struct libssh2_agent_publickey *identity; | |
465 | struct libssh2_agent_publickey *prev_identity = NULL; | |
466 | ||
467 | userauthlist = libssh2_userauth_list(s->session, user, strlen(user)); | |
468 | if (strstr(userauthlist, "publickey") == NULL) { | |
469 | ret = -EPERM; | |
4618e658 MA |
470 | error_setg(errp, |
471 | "remote server does not support \"publickey\" authentication"); | |
0a12ec87 RJ |
472 | goto out; |
473 | } | |
474 | ||
475 | /* Connect to ssh-agent and try each identity in turn. */ | |
476 | agent = libssh2_agent_init(s->session); | |
477 | if (!agent) { | |
478 | ret = -EINVAL; | |
4618e658 | 479 | session_error_setg(errp, s, "failed to initialize ssh-agent support"); |
0a12ec87 RJ |
480 | goto out; |
481 | } | |
482 | if (libssh2_agent_connect(agent)) { | |
483 | ret = -ECONNREFUSED; | |
4618e658 | 484 | session_error_setg(errp, s, "failed to connect to ssh-agent"); |
0a12ec87 RJ |
485 | goto out; |
486 | } | |
487 | if (libssh2_agent_list_identities(agent)) { | |
488 | ret = -EINVAL; | |
4618e658 MA |
489 | session_error_setg(errp, s, |
490 | "failed requesting identities from ssh-agent"); | |
0a12ec87 RJ |
491 | goto out; |
492 | } | |
493 | ||
494 | for(;;) { | |
495 | r = libssh2_agent_get_identity(agent, &identity, prev_identity); | |
496 | if (r == 1) { /* end of list */ | |
497 | break; | |
498 | } | |
499 | if (r < 0) { | |
500 | ret = -EINVAL; | |
4618e658 MA |
501 | session_error_setg(errp, s, |
502 | "failed to obtain identity from ssh-agent"); | |
0a12ec87 RJ |
503 | goto out; |
504 | } | |
505 | r = libssh2_agent_userauth(agent, user, identity); | |
506 | if (r == 0) { | |
507 | /* Authenticated! */ | |
508 | ret = 0; | |
509 | goto out; | |
510 | } | |
511 | /* Failed to authenticate with this identity, try the next one. */ | |
512 | prev_identity = identity; | |
513 | } | |
514 | ||
515 | ret = -EPERM; | |
4618e658 MA |
516 | error_setg(errp, "failed to authenticate using publickey authentication " |
517 | "and the identities held by your ssh-agent"); | |
0a12ec87 RJ |
518 | |
519 | out: | |
520 | if (agent != NULL) { | |
521 | /* Note: libssh2 implementation implicitly calls | |
522 | * libssh2_agent_disconnect if necessary. | |
523 | */ | |
524 | libssh2_agent_free(agent); | |
525 | } | |
526 | ||
527 | return ret; | |
528 | } | |
529 | ||
8a6a8089 HR |
530 | static QemuOptsList ssh_runtime_opts = { |
531 | .name = "ssh", | |
532 | .head = QTAILQ_HEAD_INITIALIZER(ssh_runtime_opts.head), | |
533 | .desc = { | |
534 | { | |
535 | .name = "host", | |
536 | .type = QEMU_OPT_STRING, | |
537 | .help = "Host to connect to", | |
538 | }, | |
539 | { | |
540 | .name = "port", | |
541 | .type = QEMU_OPT_NUMBER, | |
542 | .help = "Port to connect to", | |
543 | }, | |
544 | { | |
545 | .name = "path", | |
546 | .type = QEMU_OPT_STRING, | |
547 | .help = "Path of the image on the host", | |
548 | }, | |
549 | { | |
550 | .name = "user", | |
551 | .type = QEMU_OPT_STRING, | |
552 | .help = "User as which to connect", | |
553 | }, | |
554 | { | |
555 | .name = "host_key_check", | |
556 | .type = QEMU_OPT_STRING, | |
557 | .help = "Defines how and what to check the host key against", | |
558 | }, | |
fbd5c4c0 | 559 | { /* end of list */ } |
8a6a8089 HR |
560 | }, |
561 | }; | |
562 | ||
0da5b8ef AA |
563 | static bool ssh_process_legacy_socket_options(QDict *output_opts, |
564 | QemuOpts *legacy_opts, | |
565 | Error **errp) | |
566 | { | |
567 | const char *host = qemu_opt_get(legacy_opts, "host"); | |
568 | const char *port = qemu_opt_get(legacy_opts, "port"); | |
569 | ||
570 | if (!host && port) { | |
571 | error_setg(errp, "port may not be used without host"); | |
572 | return false; | |
573 | } | |
574 | ||
575 | if (host) { | |
46f5ac20 EB |
576 | qdict_put_str(output_opts, "server.host", host); |
577 | qdict_put_str(output_opts, "server.port", port ?: stringify(22)); | |
0da5b8ef AA |
578 | } |
579 | ||
580 | return true; | |
581 | } | |
582 | ||
9a80832a | 583 | static InetSocketAddress *ssh_config(QDict *options, Error **errp) |
0da5b8ef AA |
584 | { |
585 | InetSocketAddress *inet = NULL; | |
586 | QDict *addr = NULL; | |
587 | QObject *crumpled_addr = NULL; | |
588 | Visitor *iv = NULL; | |
589 | Error *local_error = NULL; | |
590 | ||
591 | qdict_extract_subqdict(options, &addr, "server."); | |
592 | if (!qdict_size(addr)) { | |
593 | error_setg(errp, "SSH server address missing"); | |
594 | goto out; | |
595 | } | |
596 | ||
597 | crumpled_addr = qdict_crumple(addr, errp); | |
598 | if (!crumpled_addr) { | |
599 | goto out; | |
600 | } | |
601 | ||
129c7d1c MA |
602 | /* |
603 | * FIXME .numeric, .to, .ipv4 or .ipv6 don't work with -drive. | |
604 | * .to doesn't matter, it's ignored anyway. | |
605 | * That's because when @options come from -blockdev or | |
606 | * blockdev_add, members are typed according to the QAPI schema, | |
607 | * but when they come from -drive, they're all QString. The | |
608 | * visitor expects the former. | |
609 | */ | |
048abb7b | 610 | iv = qobject_input_visitor_new(crumpled_addr); |
0da5b8ef AA |
611 | visit_type_InetSocketAddress(iv, NULL, &inet, &local_error); |
612 | if (local_error) { | |
613 | error_propagate(errp, local_error); | |
614 | goto out; | |
615 | } | |
616 | ||
617 | out: | |
618 | QDECREF(addr); | |
619 | qobject_decref(crumpled_addr); | |
620 | visit_free(iv); | |
621 | return inet; | |
622 | } | |
623 | ||
0a12ec87 | 624 | static int connect_to_ssh(BDRVSSHState *s, QDict *options, |
5f0c39e5 | 625 | int ssh_flags, int creat_mode, Error **errp) |
0a12ec87 RJ |
626 | { |
627 | int r, ret; | |
8a6a8089 HR |
628 | QemuOpts *opts = NULL; |
629 | Error *local_err = NULL; | |
0da5b8ef AA |
630 | const char *user, *path, *host_key_check; |
631 | long port = 0; | |
0a12ec87 | 632 | |
8a6a8089 HR |
633 | opts = qemu_opts_create(&ssh_runtime_opts, NULL, 0, &error_abort); |
634 | qemu_opts_absorb_qdict(opts, options, &local_err); | |
635 | if (local_err) { | |
18fe46d7 | 636 | ret = -EINVAL; |
8a6a8089 | 637 | error_propagate(errp, local_err); |
18fe46d7 RJ |
638 | goto err; |
639 | } | |
0a12ec87 | 640 | |
0da5b8ef | 641 | if (!ssh_process_legacy_socket_options(options, opts, errp)) { |
8a6a8089 | 642 | ret = -EINVAL; |
8a6a8089 | 643 | goto err; |
0a12ec87 RJ |
644 | } |
645 | ||
8a6a8089 HR |
646 | path = qemu_opt_get(opts, "path"); |
647 | if (!path) { | |
18fe46d7 RJ |
648 | ret = -EINVAL; |
649 | error_setg(errp, "No path was specified"); | |
650 | goto err; | |
651 | } | |
0a12ec87 | 652 | |
8a6a8089 HR |
653 | user = qemu_opt_get(opts, "user"); |
654 | if (!user) { | |
0a12ec87 RJ |
655 | user = g_get_user_name(); |
656 | if (!user) { | |
5f0c39e5 | 657 | error_setg_errno(errp, errno, "Can't get user name"); |
0a12ec87 RJ |
658 | ret = -errno; |
659 | goto err; | |
660 | } | |
661 | } | |
662 | ||
8a6a8089 HR |
663 | host_key_check = qemu_opt_get(opts, "host_key_check"); |
664 | if (!host_key_check) { | |
0a12ec87 RJ |
665 | host_key_check = "yes"; |
666 | } | |
667 | ||
0da5b8ef | 668 | /* Pop the config into our state object, Exit if invalid */ |
9a80832a | 669 | s->inet = ssh_config(options, errp); |
0da5b8ef AA |
670 | if (!s->inet) { |
671 | ret = -EINVAL; | |
672 | goto err; | |
673 | } | |
674 | ||
675 | if (qemu_strtol(s->inet->port, NULL, 10, &port) < 0) { | |
676 | error_setg(errp, "Use only numeric port value"); | |
677 | ret = -EINVAL; | |
678 | goto err; | |
679 | } | |
9a2d462e | 680 | |
0a12ec87 | 681 | /* Open the socket and connect. */ |
b2587932 | 682 | s->sock = inet_connect_saddr(s->inet, errp); |
5f0c39e5 | 683 | if (s->sock < 0) { |
325e3904 | 684 | ret = -EIO; |
0a12ec87 RJ |
685 | goto err; |
686 | } | |
687 | ||
688 | /* Create SSH session. */ | |
689 | s->session = libssh2_session_init(); | |
690 | if (!s->session) { | |
691 | ret = -EINVAL; | |
5f0c39e5 | 692 | session_error_setg(errp, s, "failed to initialize libssh2 session"); |
0a12ec87 RJ |
693 | goto err; |
694 | } | |
695 | ||
696 | #if TRACE_LIBSSH2 != 0 | |
697 | libssh2_trace(s->session, TRACE_LIBSSH2); | |
698 | #endif | |
699 | ||
700 | r = libssh2_session_handshake(s->session, s->sock); | |
701 | if (r != 0) { | |
702 | ret = -EINVAL; | |
5f0c39e5 | 703 | session_error_setg(errp, s, "failed to establish SSH session"); |
0a12ec87 RJ |
704 | goto err; |
705 | } | |
706 | ||
707 | /* Check the remote host's key against known_hosts. */ | |
0da5b8ef AA |
708 | ret = check_host_key(s, s->inet->host, port, host_key_check, |
709 | errp); | |
0a12ec87 RJ |
710 | if (ret < 0) { |
711 | goto err; | |
712 | } | |
713 | ||
714 | /* Authenticate. */ | |
5f0c39e5 | 715 | ret = authenticate(s, user, errp); |
0a12ec87 RJ |
716 | if (ret < 0) { |
717 | goto err; | |
718 | } | |
719 | ||
720 | /* Start SFTP. */ | |
721 | s->sftp = libssh2_sftp_init(s->session); | |
722 | if (!s->sftp) { | |
5f0c39e5 | 723 | session_error_setg(errp, s, "failed to initialize sftp handle"); |
0a12ec87 RJ |
724 | ret = -EINVAL; |
725 | goto err; | |
726 | } | |
727 | ||
728 | /* Open the remote file. */ | |
729 | DPRINTF("opening file %s flags=0x%x creat_mode=0%o", | |
730 | path, ssh_flags, creat_mode); | |
731 | s->sftp_handle = libssh2_sftp_open(s->sftp, path, ssh_flags, creat_mode); | |
732 | if (!s->sftp_handle) { | |
5496fb1a | 733 | session_error_setg(errp, s, "failed to open remote file '%s'", path); |
0a12ec87 RJ |
734 | ret = -EINVAL; |
735 | goto err; | |
736 | } | |
737 | ||
8a6a8089 HR |
738 | qemu_opts_del(opts); |
739 | ||
0a12ec87 RJ |
740 | r = libssh2_sftp_fstat(s->sftp_handle, &s->attrs); |
741 | if (r < 0) { | |
5496fb1a | 742 | sftp_error_setg(errp, s, "failed to read file attributes"); |
0a12ec87 RJ |
743 | return -EINVAL; |
744 | } | |
745 | ||
0a12ec87 RJ |
746 | return 0; |
747 | ||
748 | err: | |
749 | if (s->sftp_handle) { | |
750 | libssh2_sftp_close(s->sftp_handle); | |
751 | } | |
752 | s->sftp_handle = NULL; | |
753 | if (s->sftp) { | |
754 | libssh2_sftp_shutdown(s->sftp); | |
755 | } | |
756 | s->sftp = NULL; | |
757 | if (s->session) { | |
758 | libssh2_session_disconnect(s->session, | |
759 | "from qemu ssh client: " | |
760 | "error opening connection"); | |
761 | libssh2_session_free(s->session); | |
762 | } | |
763 | s->session = NULL; | |
0a12ec87 | 764 | |
8a6a8089 HR |
765 | qemu_opts_del(opts); |
766 | ||
0a12ec87 RJ |
767 | return ret; |
768 | } | |
769 | ||
015a1036 HR |
770 | static int ssh_file_open(BlockDriverState *bs, QDict *options, int bdrv_flags, |
771 | Error **errp) | |
0a12ec87 RJ |
772 | { |
773 | BDRVSSHState *s = bs->opaque; | |
774 | int ret; | |
775 | int ssh_flags; | |
776 | ||
777 | ssh_state_init(s); | |
778 | ||
779 | ssh_flags = LIBSSH2_FXF_READ; | |
780 | if (bdrv_flags & BDRV_O_RDWR) { | |
781 | ssh_flags |= LIBSSH2_FXF_WRITE; | |
782 | } | |
783 | ||
784 | /* Start up SSH. */ | |
5496fb1a | 785 | ret = connect_to_ssh(s, options, ssh_flags, 0, errp); |
0a12ec87 RJ |
786 | if (ret < 0) { |
787 | goto err; | |
788 | } | |
789 | ||
790 | /* Go non-blocking. */ | |
791 | libssh2_session_set_blocking(s->session, 0); | |
792 | ||
793 | return 0; | |
794 | ||
795 | err: | |
796 | if (s->sock >= 0) { | |
797 | close(s->sock); | |
798 | } | |
799 | s->sock = -1; | |
800 | ||
801 | return ret; | |
802 | } | |
803 | ||
766181fe CL |
804 | static QemuOptsList ssh_create_opts = { |
805 | .name = "ssh-create-opts", | |
806 | .head = QTAILQ_HEAD_INITIALIZER(ssh_create_opts.head), | |
807 | .desc = { | |
808 | { | |
809 | .name = BLOCK_OPT_SIZE, | |
810 | .type = QEMU_OPT_SIZE, | |
811 | .help = "Virtual disk size" | |
812 | }, | |
813 | { /* end of list */ } | |
814 | } | |
0a12ec87 RJ |
815 | }; |
816 | ||
766181fe | 817 | static int ssh_create(const char *filename, QemuOpts *opts, Error **errp) |
0a12ec87 RJ |
818 | { |
819 | int r, ret; | |
0a12ec87 RJ |
820 | int64_t total_size = 0; |
821 | QDict *uri_options = NULL; | |
822 | BDRVSSHState s; | |
823 | ssize_t r2; | |
824 | char c[1] = { '\0' }; | |
825 | ||
826 | ssh_state_init(&s); | |
827 | ||
828 | /* Get desired file size. */ | |
c2eb918e HT |
829 | total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), |
830 | BDRV_SECTOR_SIZE); | |
0a12ec87 RJ |
831 | DPRINTF("total_size=%" PRIi64, total_size); |
832 | ||
833 | uri_options = qdict_new(); | |
5496fb1a | 834 | r = parse_uri(filename, uri_options, errp); |
0a12ec87 | 835 | if (r < 0) { |
0a12ec87 RJ |
836 | ret = r; |
837 | goto out; | |
838 | } | |
839 | ||
840 | r = connect_to_ssh(&s, uri_options, | |
841 | LIBSSH2_FXF_READ|LIBSSH2_FXF_WRITE| | |
5f0c39e5 | 842 | LIBSSH2_FXF_CREAT|LIBSSH2_FXF_TRUNC, |
5496fb1a | 843 | 0644, errp); |
0a12ec87 RJ |
844 | if (r < 0) { |
845 | ret = r; | |
846 | goto out; | |
847 | } | |
848 | ||
849 | if (total_size > 0) { | |
850 | libssh2_sftp_seek64(s.sftp_handle, total_size-1); | |
851 | r2 = libssh2_sftp_write(s.sftp_handle, c, 1); | |
852 | if (r2 < 0) { | |
5496fb1a | 853 | sftp_error_setg(errp, &s, "truncate failed"); |
0a12ec87 RJ |
854 | ret = -EINVAL; |
855 | goto out; | |
856 | } | |
857 | s.attrs.filesize = total_size; | |
858 | } | |
859 | ||
860 | ret = 0; | |
861 | ||
862 | out: | |
863 | ssh_state_free(&s); | |
864 | if (uri_options != NULL) { | |
865 | QDECREF(uri_options); | |
866 | } | |
867 | return ret; | |
868 | } | |
869 | ||
870 | static void ssh_close(BlockDriverState *bs) | |
871 | { | |
872 | BDRVSSHState *s = bs->opaque; | |
873 | ||
874 | ssh_state_free(s); | |
875 | } | |
876 | ||
0b3f21e6 RJ |
877 | static int ssh_has_zero_init(BlockDriverState *bs) |
878 | { | |
879 | BDRVSSHState *s = bs->opaque; | |
880 | /* Assume false, unless we can positively prove it's true. */ | |
881 | int has_zero_init = 0; | |
882 | ||
883 | if (s->attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) { | |
884 | if (s->attrs.permissions & LIBSSH2_SFTP_S_IFREG) { | |
885 | has_zero_init = 1; | |
886 | } | |
887 | } | |
888 | ||
889 | return has_zero_init; | |
890 | } | |
891 | ||
5aca18a4 PB |
892 | typedef struct BDRVSSHRestart { |
893 | BlockDriverState *bs; | |
894 | Coroutine *co; | |
895 | } BDRVSSHRestart; | |
896 | ||
0a12ec87 RJ |
897 | static void restart_coroutine(void *opaque) |
898 | { | |
5aca18a4 PB |
899 | BDRVSSHRestart *restart = opaque; |
900 | BlockDriverState *bs = restart->bs; | |
901 | BDRVSSHState *s = bs->opaque; | |
902 | AioContext *ctx = bdrv_get_aio_context(bs); | |
0a12ec87 | 903 | |
5aca18a4 PB |
904 | DPRINTF("co=%p", restart->co); |
905 | aio_set_fd_handler(ctx, s->sock, false, NULL, NULL, NULL, NULL); | |
0a12ec87 | 906 | |
5aca18a4 | 907 | aio_co_wake(restart->co); |
0a12ec87 RJ |
908 | } |
909 | ||
9d456654 PB |
910 | /* A non-blocking call returned EAGAIN, so yield, ensuring the |
911 | * handlers are set up so that we'll be rescheduled when there is an | |
912 | * interesting event on the socket. | |
913 | */ | |
914 | static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs) | |
0a12ec87 RJ |
915 | { |
916 | int r; | |
917 | IOHandler *rd_handler = NULL, *wr_handler = NULL; | |
5aca18a4 PB |
918 | BDRVSSHRestart restart = { |
919 | .bs = bs, | |
920 | .co = qemu_coroutine_self() | |
921 | }; | |
0a12ec87 RJ |
922 | |
923 | r = libssh2_session_block_directions(s->session); | |
924 | ||
925 | if (r & LIBSSH2_SESSION_BLOCK_INBOUND) { | |
926 | rd_handler = restart_coroutine; | |
927 | } | |
928 | if (r & LIBSSH2_SESSION_BLOCK_OUTBOUND) { | |
929 | wr_handler = restart_coroutine; | |
930 | } | |
931 | ||
932 | DPRINTF("s->sock=%d rd_handler=%p wr_handler=%p", s->sock, | |
933 | rd_handler, wr_handler); | |
934 | ||
2af0b200 | 935 | aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock, |
5aca18a4 | 936 | false, rd_handler, wr_handler, NULL, &restart); |
0a12ec87 | 937 | qemu_coroutine_yield(); |
9d456654 | 938 | DPRINTF("s->sock=%d - back", s->sock); |
0a12ec87 RJ |
939 | } |
940 | ||
941 | /* SFTP has a function `libssh2_sftp_seek64' which seeks to a position | |
942 | * in the remote file. Notice that it just updates a field in the | |
943 | * sftp_handle structure, so there is no network traffic and it cannot | |
944 | * fail. | |
945 | * | |
946 | * However, `libssh2_sftp_seek64' does have a catastrophic effect on | |
947 | * performance since it causes the handle to throw away all in-flight | |
948 | * reads and buffered readahead data. Therefore this function tries | |
949 | * to be intelligent about when to call the underlying libssh2 function. | |
950 | */ | |
951 | #define SSH_SEEK_WRITE 0 | |
952 | #define SSH_SEEK_READ 1 | |
953 | #define SSH_SEEK_FORCE 2 | |
954 | ||
955 | static void ssh_seek(BDRVSSHState *s, int64_t offset, int flags) | |
956 | { | |
957 | bool op_read = (flags & SSH_SEEK_READ) != 0; | |
958 | bool force = (flags & SSH_SEEK_FORCE) != 0; | |
959 | ||
960 | if (force || op_read != s->offset_op_read || offset != s->offset) { | |
961 | DPRINTF("seeking to offset=%" PRIi64, offset); | |
962 | libssh2_sftp_seek64(s->sftp_handle, offset); | |
963 | s->offset = offset; | |
964 | s->offset_op_read = op_read; | |
965 | } | |
966 | } | |
967 | ||
2af0b200 | 968 | static coroutine_fn int ssh_read(BDRVSSHState *s, BlockDriverState *bs, |
0a12ec87 RJ |
969 | int64_t offset, size_t size, |
970 | QEMUIOVector *qiov) | |
971 | { | |
972 | ssize_t r; | |
973 | size_t got; | |
974 | char *buf, *end_of_vec; | |
975 | struct iovec *i; | |
976 | ||
977 | DPRINTF("offset=%" PRIi64 " size=%zu", offset, size); | |
978 | ||
979 | ssh_seek(s, offset, SSH_SEEK_READ); | |
980 | ||
981 | /* This keeps track of the current iovec element ('i'), where we | |
982 | * will write to next ('buf'), and the end of the current iovec | |
983 | * ('end_of_vec'). | |
984 | */ | |
985 | i = &qiov->iov[0]; | |
986 | buf = i->iov_base; | |
987 | end_of_vec = i->iov_base + i->iov_len; | |
988 | ||
989 | /* libssh2 has a hard-coded limit of 2000 bytes per request, | |
990 | * although it will also do readahead behind our backs. Therefore | |
991 | * we may have to do repeated reads here until we have read 'size' | |
992 | * bytes. | |
993 | */ | |
994 | for (got = 0; got < size; ) { | |
995 | again: | |
996 | DPRINTF("sftp_read buf=%p size=%zu", buf, end_of_vec - buf); | |
997 | r = libssh2_sftp_read(s->sftp_handle, buf, end_of_vec - buf); | |
998 | DPRINTF("sftp_read returned %zd", r); | |
999 | ||
1000 | if (r == LIBSSH2_ERROR_EAGAIN || r == LIBSSH2_ERROR_TIMEOUT) { | |
2af0b200 | 1001 | co_yield(s, bs); |
0a12ec87 RJ |
1002 | goto again; |
1003 | } | |
1004 | if (r < 0) { | |
1005 | sftp_error_report(s, "read failed"); | |
1006 | s->offset = -1; | |
1007 | return -EIO; | |
1008 | } | |
1009 | if (r == 0) { | |
1010 | /* EOF: Short read so pad the buffer with zeroes and return it. */ | |
1011 | qemu_iovec_memset(qiov, got, 0, size - got); | |
1012 | return 0; | |
1013 | } | |
1014 | ||
1015 | got += r; | |
1016 | buf += r; | |
1017 | s->offset += r; | |
1018 | if (buf >= end_of_vec && got < size) { | |
1019 | i++; | |
1020 | buf = i->iov_base; | |
1021 | end_of_vec = i->iov_base + i->iov_len; | |
1022 | } | |
1023 | } | |
1024 | ||
1025 | return 0; | |
1026 | } | |
1027 | ||
1028 | static coroutine_fn int ssh_co_readv(BlockDriverState *bs, | |
1029 | int64_t sector_num, | |
1030 | int nb_sectors, QEMUIOVector *qiov) | |
1031 | { | |
1032 | BDRVSSHState *s = bs->opaque; | |
1033 | int ret; | |
1034 | ||
1035 | qemu_co_mutex_lock(&s->lock); | |
2af0b200 | 1036 | ret = ssh_read(s, bs, sector_num * BDRV_SECTOR_SIZE, |
0a12ec87 RJ |
1037 | nb_sectors * BDRV_SECTOR_SIZE, qiov); |
1038 | qemu_co_mutex_unlock(&s->lock); | |
1039 | ||
1040 | return ret; | |
1041 | } | |
1042 | ||
2af0b200 | 1043 | static int ssh_write(BDRVSSHState *s, BlockDriverState *bs, |
0a12ec87 RJ |
1044 | int64_t offset, size_t size, |
1045 | QEMUIOVector *qiov) | |
1046 | { | |
1047 | ssize_t r; | |
1048 | size_t written; | |
1049 | char *buf, *end_of_vec; | |
1050 | struct iovec *i; | |
1051 | ||
1052 | DPRINTF("offset=%" PRIi64 " size=%zu", offset, size); | |
1053 | ||
1054 | ssh_seek(s, offset, SSH_SEEK_WRITE); | |
1055 | ||
1056 | /* This keeps track of the current iovec element ('i'), where we | |
1057 | * will read from next ('buf'), and the end of the current iovec | |
1058 | * ('end_of_vec'). | |
1059 | */ | |
1060 | i = &qiov->iov[0]; | |
1061 | buf = i->iov_base; | |
1062 | end_of_vec = i->iov_base + i->iov_len; | |
1063 | ||
1064 | for (written = 0; written < size; ) { | |
1065 | again: | |
1066 | DPRINTF("sftp_write buf=%p size=%zu", buf, end_of_vec - buf); | |
1067 | r = libssh2_sftp_write(s->sftp_handle, buf, end_of_vec - buf); | |
1068 | DPRINTF("sftp_write returned %zd", r); | |
1069 | ||
1070 | if (r == LIBSSH2_ERROR_EAGAIN || r == LIBSSH2_ERROR_TIMEOUT) { | |
2af0b200 | 1071 | co_yield(s, bs); |
0a12ec87 RJ |
1072 | goto again; |
1073 | } | |
1074 | if (r < 0) { | |
1075 | sftp_error_report(s, "write failed"); | |
1076 | s->offset = -1; | |
1077 | return -EIO; | |
1078 | } | |
1079 | /* The libssh2 API is very unclear about this. A comment in | |
1080 | * the code says "nothing was acked, and no EAGAIN was | |
1081 | * received!" which apparently means that no data got sent | |
1082 | * out, and the underlying channel didn't return any EAGAIN | |
1083 | * indication. I think this is a bug in either libssh2 or | |
1084 | * OpenSSH (server-side). In any case, forcing a seek (to | |
1085 | * discard libssh2 internal buffers), and then trying again | |
1086 | * works for me. | |
1087 | */ | |
1088 | if (r == 0) { | |
1089 | ssh_seek(s, offset + written, SSH_SEEK_WRITE|SSH_SEEK_FORCE); | |
2af0b200 | 1090 | co_yield(s, bs); |
0a12ec87 RJ |
1091 | goto again; |
1092 | } | |
1093 | ||
1094 | written += r; | |
1095 | buf += r; | |
1096 | s->offset += r; | |
1097 | if (buf >= end_of_vec && written < size) { | |
1098 | i++; | |
1099 | buf = i->iov_base; | |
1100 | end_of_vec = i->iov_base + i->iov_len; | |
1101 | } | |
1102 | ||
1103 | if (offset + written > s->attrs.filesize) | |
1104 | s->attrs.filesize = offset + written; | |
1105 | } | |
1106 | ||
1107 | return 0; | |
1108 | } | |
1109 | ||
1110 | static coroutine_fn int ssh_co_writev(BlockDriverState *bs, | |
1111 | int64_t sector_num, | |
1112 | int nb_sectors, QEMUIOVector *qiov) | |
1113 | { | |
1114 | BDRVSSHState *s = bs->opaque; | |
1115 | int ret; | |
1116 | ||
1117 | qemu_co_mutex_lock(&s->lock); | |
2af0b200 | 1118 | ret = ssh_write(s, bs, sector_num * BDRV_SECTOR_SIZE, |
0a12ec87 RJ |
1119 | nb_sectors * BDRV_SECTOR_SIZE, qiov); |
1120 | qemu_co_mutex_unlock(&s->lock); | |
1121 | ||
1122 | return ret; | |
1123 | } | |
1124 | ||
9a2d462e RJ |
1125 | static void unsafe_flush_warning(BDRVSSHState *s, const char *what) |
1126 | { | |
1127 | if (!s->unsafe_flush_warning) { | |
3dc6f869 AF |
1128 | warn_report("ssh server %s does not support fsync", |
1129 | s->inet->host); | |
9a2d462e RJ |
1130 | if (what) { |
1131 | error_report("to support fsync, you need %s", what); | |
1132 | } | |
1133 | s->unsafe_flush_warning = true; | |
1134 | } | |
1135 | } | |
1136 | ||
1137 | #ifdef HAS_LIBSSH2_SFTP_FSYNC | |
1138 | ||
2af0b200 | 1139 | static coroutine_fn int ssh_flush(BDRVSSHState *s, BlockDriverState *bs) |
9a2d462e RJ |
1140 | { |
1141 | int r; | |
1142 | ||
1143 | DPRINTF("fsync"); | |
1144 | again: | |
1145 | r = libssh2_sftp_fsync(s->sftp_handle); | |
1146 | if (r == LIBSSH2_ERROR_EAGAIN || r == LIBSSH2_ERROR_TIMEOUT) { | |
2af0b200 | 1147 | co_yield(s, bs); |
9a2d462e RJ |
1148 | goto again; |
1149 | } | |
1150 | if (r == LIBSSH2_ERROR_SFTP_PROTOCOL && | |
1151 | libssh2_sftp_last_error(s->sftp) == LIBSSH2_FX_OP_UNSUPPORTED) { | |
1152 | unsafe_flush_warning(s, "OpenSSH >= 6.3"); | |
1153 | return 0; | |
1154 | } | |
1155 | if (r < 0) { | |
1156 | sftp_error_report(s, "fsync failed"); | |
1157 | return -EIO; | |
1158 | } | |
1159 | ||
1160 | return 0; | |
1161 | } | |
1162 | ||
1163 | static coroutine_fn int ssh_co_flush(BlockDriverState *bs) | |
1164 | { | |
1165 | BDRVSSHState *s = bs->opaque; | |
1166 | int ret; | |
1167 | ||
1168 | qemu_co_mutex_lock(&s->lock); | |
2af0b200 | 1169 | ret = ssh_flush(s, bs); |
9a2d462e RJ |
1170 | qemu_co_mutex_unlock(&s->lock); |
1171 | ||
1172 | return ret; | |
1173 | } | |
1174 | ||
1175 | #else /* !HAS_LIBSSH2_SFTP_FSYNC */ | |
1176 | ||
1177 | static coroutine_fn int ssh_co_flush(BlockDriverState *bs) | |
1178 | { | |
1179 | BDRVSSHState *s = bs->opaque; | |
1180 | ||
1181 | unsafe_flush_warning(s, "libssh2 >= 1.4.4"); | |
1182 | return 0; | |
1183 | } | |
1184 | ||
1185 | #endif /* !HAS_LIBSSH2_SFTP_FSYNC */ | |
1186 | ||
0a12ec87 RJ |
1187 | static int64_t ssh_getlength(BlockDriverState *bs) |
1188 | { | |
1189 | BDRVSSHState *s = bs->opaque; | |
1190 | int64_t length; | |
1191 | ||
1192 | /* Note we cannot make a libssh2 call here. */ | |
1193 | length = (int64_t) s->attrs.filesize; | |
1194 | DPRINTF("length=%" PRIi64, length); | |
1195 | ||
1196 | return length; | |
1197 | } | |
1198 | ||
1199 | static BlockDriver bdrv_ssh = { | |
1200 | .format_name = "ssh", | |
1201 | .protocol_name = "ssh", | |
1202 | .instance_size = sizeof(BDRVSSHState), | |
1203 | .bdrv_parse_filename = ssh_parse_filename, | |
1204 | .bdrv_file_open = ssh_file_open, | |
c282e1fd | 1205 | .bdrv_create = ssh_create, |
0a12ec87 | 1206 | .bdrv_close = ssh_close, |
0b3f21e6 | 1207 | .bdrv_has_zero_init = ssh_has_zero_init, |
0a12ec87 RJ |
1208 | .bdrv_co_readv = ssh_co_readv, |
1209 | .bdrv_co_writev = ssh_co_writev, | |
1210 | .bdrv_getlength = ssh_getlength, | |
9a2d462e | 1211 | .bdrv_co_flush_to_disk = ssh_co_flush, |
766181fe | 1212 | .create_opts = &ssh_create_opts, |
0a12ec87 RJ |
1213 | }; |
1214 | ||
1215 | static void bdrv_ssh_init(void) | |
1216 | { | |
1217 | int r; | |
1218 | ||
1219 | r = libssh2_init(0); | |
1220 | if (r != 0) { | |
1221 | fprintf(stderr, "libssh2 initialization failed, %d\n", r); | |
1222 | exit(EXIT_FAILURE); | |
1223 | } | |
1224 | ||
1225 | bdrv_register(&bdrv_ssh); | |
1226 | } | |
1227 | ||
1228 | block_init(bdrv_ssh_init); |