]>
Commit | Line | Data |
---|---|---|
798bfe00 | 1 | /* |
5de47735 | 2 | * Copyright (C) 2016-2019 Red Hat, Inc. |
798bfe00 FZ |
3 | * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws> |
4 | * | |
5 | * Network Block Device Client Side | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; under version 2 of the License. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, see <http://www.gnu.org/licenses/>. | |
18 | */ | |
19 | ||
d38ea87a | 20 | #include "qemu/osdep.h" |
da34e65c | 21 | #include "qapi/error.h" |
dc5e9ac7 | 22 | #include "qemu/queue.h" |
9588463e | 23 | #include "trace.h" |
798bfe00 | 24 | #include "nbd-internal.h" |
7c6f5ddc | 25 | #include "qemu/cutils.h" |
798bfe00 | 26 | |
798bfe00 FZ |
27 | /* Definitions for opaque data types */ |
28 | ||
29 | static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports); | |
30 | ||
31 | /* That's all folks */ | |
32 | ||
33 | /* Basic flow for negotiation | |
34 | ||
35 | Server Client | |
36 | Negotiate | |
37 | ||
38 | or | |
39 | ||
40 | Server Client | |
41 | Negotiate #1 | |
42 | Option | |
43 | Negotiate #2 | |
44 | ||
45 | ---- | |
46 | ||
47 | followed by | |
48 | ||
49 | Server Client | |
50 | Request | |
51 | Response | |
52 | Request | |
53 | Response | |
54 | ... | |
55 | ... | |
56 | Request (type == 2) | |
57 | ||
58 | */ | |
59 | ||
c8a3a1b6 EB |
60 | /* Send an option request. |
61 | * | |
62 | * The request is for option @opt, with @data containing @len bytes of | |
63 | * additional payload for the request (@len may be -1 to treat @data as | |
64 | * a C string; and @data may be NULL if @len is 0). | |
65 | * Return 0 if successful, -1 with errp set if it is impossible to | |
66 | * continue. */ | |
67 | static int nbd_send_option_request(QIOChannel *ioc, uint32_t opt, | |
68 | uint32_t len, const char *data, | |
69 | Error **errp) | |
70 | { | |
420a4e95 | 71 | NBDOption req; |
c8a3a1b6 EB |
72 | QEMU_BUILD_BUG_ON(sizeof(req) != 16); |
73 | ||
74 | if (len == -1) { | |
75 | req.length = len = strlen(data); | |
76 | } | |
3736cc5b | 77 | trace_nbd_send_option_request(opt, nbd_opt_lookup(opt), len); |
c8a3a1b6 EB |
78 | |
79 | stq_be_p(&req.magic, NBD_OPTS_MAGIC); | |
80 | stl_be_p(&req.option, opt); | |
81 | stl_be_p(&req.length, len); | |
82 | ||
d1fdf257 | 83 | if (nbd_write(ioc, &req, sizeof(req), errp) < 0) { |
cb6b1a3f | 84 | error_prepend(errp, "Failed to send option request header: "); |
c8a3a1b6 EB |
85 | return -1; |
86 | } | |
87 | ||
d1fdf257 | 88 | if (len && nbd_write(ioc, (char *) data, len, errp) < 0) { |
cb6b1a3f | 89 | error_prepend(errp, "Failed to send option request data: "); |
c8a3a1b6 EB |
90 | return -1; |
91 | } | |
92 | ||
93 | return 0; | |
94 | } | |
95 | ||
2cdbf413 EB |
96 | /* Send NBD_OPT_ABORT as a courtesy to let the server know that we are |
97 | * not going to attempt further negotiation. */ | |
98 | static void nbd_send_opt_abort(QIOChannel *ioc) | |
99 | { | |
100 | /* Technically, a compliant server is supposed to reply to us; but | |
101 | * older servers disconnected instead. At any rate, we're allowed | |
102 | * to disconnect without waiting for the server reply, so we don't | |
103 | * even care if the request makes it to the server, let alone | |
104 | * waiting around for whether the server replies. */ | |
105 | nbd_send_option_request(ioc, NBD_OPT_ABORT, 0, NULL, NULL); | |
106 | } | |
107 | ||
108 | ||
c8a3a1b6 EB |
109 | /* Receive the header of an option reply, which should match the given |
110 | * opt. Read through the length field, but NOT the length bytes of | |
111 | * payload. Return 0 if successful, -1 with errp set if it is | |
112 | * impossible to continue. */ | |
113 | static int nbd_receive_option_reply(QIOChannel *ioc, uint32_t opt, | |
420a4e95 | 114 | NBDOptionReply *reply, Error **errp) |
c8a3a1b6 EB |
115 | { |
116 | QEMU_BUILD_BUG_ON(sizeof(*reply) != 20); | |
e6798f06 | 117 | if (nbd_read(ioc, reply, sizeof(*reply), "option reply", errp) < 0) { |
2cdbf413 | 118 | nbd_send_opt_abort(ioc); |
c8a3a1b6 EB |
119 | return -1; |
120 | } | |
80c7c2b0 PM |
121 | reply->magic = be64_to_cpu(reply->magic); |
122 | reply->option = be32_to_cpu(reply->option); | |
123 | reply->type = be32_to_cpu(reply->type); | |
124 | reply->length = be32_to_cpu(reply->length); | |
c8a3a1b6 | 125 | |
3736cc5b EB |
126 | trace_nbd_receive_option_reply(reply->option, nbd_opt_lookup(reply->option), |
127 | reply->type, nbd_rep_lookup(reply->type), | |
128 | reply->length); | |
9344e5f5 | 129 | |
c8a3a1b6 EB |
130 | if (reply->magic != NBD_REP_MAGIC) { |
131 | error_setg(errp, "Unexpected option reply magic"); | |
2cdbf413 | 132 | nbd_send_opt_abort(ioc); |
c8a3a1b6 EB |
133 | return -1; |
134 | } | |
135 | if (reply->option != opt) { | |
6c5c0351 EB |
136 | error_setg(errp, "Unexpected option type %u (%s), expected %u (%s)", |
137 | reply->option, nbd_opt_lookup(reply->option), | |
138 | opt, nbd_opt_lookup(opt)); | |
2cdbf413 | 139 | nbd_send_opt_abort(ioc); |
c8a3a1b6 EB |
140 | return -1; |
141 | } | |
142 | return 0; | |
143 | } | |
144 | ||
5de47735 EB |
145 | /* |
146 | * If reply represents success, return 1 without further action. If | |
147 | * reply represents an error, consume the optional payload of the | |
148 | * packet on ioc. Then return 0 for unsupported (so the client can | |
149 | * fall back to other approaches), where @strict determines if only | |
150 | * ERR_UNSUP or all errors fit that category, or -1 with errp set for | |
151 | * other errors. | |
6ff58164 | 152 | */ |
420a4e95 | 153 | static int nbd_handle_reply_err(QIOChannel *ioc, NBDOptionReply *reply, |
5de47735 | 154 | bool strict, Error **errp) |
9344e5f5 | 155 | { |
5de47735 | 156 | g_autofree char *msg = NULL; |
6ff58164 | 157 | |
c8a3a1b6 | 158 | if (!(reply->type & (1 << 31))) { |
6ff58164 AB |
159 | return 1; |
160 | } | |
161 | ||
c8a3a1b6 EB |
162 | if (reply->length) { |
163 | if (reply->length > NBD_MAX_BUFFER_SIZE) { | |
28fb494f | 164 | error_setg(errp, "server error %" PRIu32 |
3736cc5b EB |
165 | " (%s) message is too long", |
166 | reply->type, nbd_rep_lookup(reply->type)); | |
5de47735 | 167 | goto err; |
6ff58164 | 168 | } |
c8a3a1b6 | 169 | msg = g_malloc(reply->length + 1); |
e6798f06 VSO |
170 | if (nbd_read(ioc, msg, reply->length, NULL, errp) < 0) { |
171 | error_prepend(errp, "Failed to read option error %" PRIu32 | |
cb6b1a3f | 172 | " (%s) message: ", |
3736cc5b | 173 | reply->type, nbd_rep_lookup(reply->type)); |
5de47735 | 174 | goto err; |
6ff58164 | 175 | } |
c8a3a1b6 | 176 | msg[reply->length] = '\0'; |
bee21ef0 EB |
177 | trace_nbd_server_error_msg(reply->type, |
178 | nbd_reply_type_lookup(reply->type), msg); | |
9344e5f5 DB |
179 | } |
180 | ||
5de47735 EB |
181 | if (reply->type == NBD_REP_ERR_UNSUP || !strict) { |
182 | trace_nbd_reply_err_ignored(reply->option, | |
183 | nbd_opt_lookup(reply->option), | |
184 | reply->type, nbd_rep_lookup(reply->type)); | |
185 | return 0; | |
186 | } | |
9344e5f5 | 187 | |
5de47735 | 188 | switch (reply->type) { |
f95910fe | 189 | case NBD_REP_ERR_POLICY: |
28fb494f | 190 | error_setg(errp, "Denied by server for option %" PRIu32 " (%s)", |
3736cc5b | 191 | reply->option, nbd_opt_lookup(reply->option)); |
f95910fe DB |
192 | break; |
193 | ||
9344e5f5 | 194 | case NBD_REP_ERR_INVALID: |
28fb494f | 195 | error_setg(errp, "Invalid parameters for option %" PRIu32 " (%s)", |
3736cc5b | 196 | reply->option, nbd_opt_lookup(reply->option)); |
9344e5f5 DB |
197 | break; |
198 | ||
b6f5d3b5 | 199 | case NBD_REP_ERR_PLATFORM: |
28fb494f | 200 | error_setg(errp, "Server lacks support for option %" PRIu32 " (%s)", |
3736cc5b | 201 | reply->option, nbd_opt_lookup(reply->option)); |
b6f5d3b5 EB |
202 | break; |
203 | ||
f95910fe | 204 | case NBD_REP_ERR_TLS_REQD: |
28fb494f | 205 | error_setg(errp, "TLS negotiation required before option %" PRIu32 |
3736cc5b EB |
206 | " (%s)", reply->option, nbd_opt_lookup(reply->option)); |
207 | break; | |
208 | ||
209 | case NBD_REP_ERR_UNKNOWN: | |
9a76bd78 | 210 | error_setg(errp, "Requested export not available"); |
f95910fe DB |
211 | break; |
212 | ||
b6f5d3b5 | 213 | case NBD_REP_ERR_SHUTDOWN: |
28fb494f | 214 | error_setg(errp, "Server shutting down before option %" PRIu32 " (%s)", |
3736cc5b EB |
215 | reply->option, nbd_opt_lookup(reply->option)); |
216 | break; | |
217 | ||
218 | case NBD_REP_ERR_BLOCK_SIZE_REQD: | |
28fb494f | 219 | error_setg(errp, "Server requires INFO_BLOCK_SIZE for option %" PRIu32 |
3736cc5b | 220 | " (%s)", reply->option, nbd_opt_lookup(reply->option)); |
b6f5d3b5 EB |
221 | break; |
222 | ||
9344e5f5 | 223 | default: |
28fb494f | 224 | error_setg(errp, "Unknown error code when asking for option %" PRIu32 |
3736cc5b | 225 | " (%s)", reply->option, nbd_opt_lookup(reply->option)); |
9344e5f5 DB |
226 | break; |
227 | } | |
228 | ||
6ff58164 | 229 | if (msg) { |
9a76bd78 | 230 | error_append_hint(errp, "server reported: %s\n", msg); |
6ff58164 AB |
231 | } |
232 | ||
5de47735 EB |
233 | err: |
234 | nbd_send_opt_abort(ioc); | |
235 | return -1; | |
9344e5f5 DB |
236 | } |
237 | ||
091d0bf3 EB |
238 | /* nbd_receive_list: |
239 | * Process another portion of the NBD_OPT_LIST reply, populating any | |
240 | * name received into *@name. If @description is non-NULL, and the | |
241 | * server provided a description, that is also populated. The caller | |
242 | * must eventually call g_free() on success. | |
243 | * Returns 1 if name and description were set and iteration must continue, | |
244 | * 0 if iteration is complete (including if OPT_LIST unsupported), | |
245 | * -1 with @errp set if an unrecoverable error occurred. | |
246 | */ | |
247 | static int nbd_receive_list(QIOChannel *ioc, char **name, char **description, | |
75368aab | 248 | Error **errp) |
9344e5f5 | 249 | { |
420a4e95 | 250 | NBDOptionReply reply; |
9344e5f5 DB |
251 | uint32_t len; |
252 | uint32_t namelen; | |
df18c04e EB |
253 | g_autofree char *local_name = NULL; |
254 | g_autofree char *local_desc = NULL; | |
6ff58164 | 255 | int error; |
9344e5f5 | 256 | |
c8a3a1b6 | 257 | if (nbd_receive_option_reply(ioc, NBD_OPT_LIST, &reply, errp) < 0) { |
9344e5f5 DB |
258 | return -1; |
259 | } | |
5de47735 | 260 | error = nbd_handle_reply_err(ioc, &reply, true, errp); |
6ff58164 AB |
261 | if (error <= 0) { |
262 | return error; | |
9344e5f5 | 263 | } |
c8a3a1b6 | 264 | len = reply.length; |
9344e5f5 | 265 | |
c8a3a1b6 | 266 | if (reply.type == NBD_REP_ACK) { |
9344e5f5 DB |
267 | if (len != 0) { |
268 | error_setg(errp, "length too long for option end"); | |
2cdbf413 | 269 | nbd_send_opt_abort(ioc); |
9344e5f5 DB |
270 | return -1; |
271 | } | |
75368aab EB |
272 | return 0; |
273 | } else if (reply.type != NBD_REP_SERVER) { | |
6c5c0351 EB |
274 | error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)", |
275 | reply.type, nbd_rep_lookup(reply.type), | |
276 | NBD_REP_SERVER, nbd_rep_lookup(NBD_REP_SERVER)); | |
75368aab EB |
277 | nbd_send_opt_abort(ioc); |
278 | return -1; | |
279 | } | |
9344e5f5 | 280 | |
75368aab EB |
281 | if (len < sizeof(namelen) || len > NBD_MAX_BUFFER_SIZE) { |
282 | error_setg(errp, "incorrect option length %" PRIu32, len); | |
283 | nbd_send_opt_abort(ioc); | |
284 | return -1; | |
285 | } | |
e6798f06 | 286 | if (nbd_read32(ioc, &namelen, "option name length", errp) < 0) { |
75368aab EB |
287 | nbd_send_opt_abort(ioc); |
288 | return -1; | |
289 | } | |
75368aab EB |
290 | len -= sizeof(namelen); |
291 | if (len < namelen) { | |
292 | error_setg(errp, "incorrect option name length"); | |
293 | nbd_send_opt_abort(ioc); | |
294 | return -1; | |
295 | } | |
75368aab | 296 | |
091d0bf3 | 297 | local_name = g_malloc(namelen + 1); |
e6798f06 | 298 | if (nbd_read(ioc, local_name, namelen, "export name", errp) < 0) { |
75368aab | 299 | nbd_send_opt_abort(ioc); |
df18c04e | 300 | return -1; |
75368aab | 301 | } |
091d0bf3 | 302 | local_name[namelen] = '\0'; |
75368aab | 303 | len -= namelen; |
091d0bf3 EB |
304 | if (len) { |
305 | local_desc = g_malloc(len + 1); | |
e6798f06 | 306 | if (nbd_read(ioc, local_desc, len, "export description", errp) < 0) { |
091d0bf3 | 307 | nbd_send_opt_abort(ioc); |
df18c04e | 308 | return -1; |
091d0bf3 EB |
309 | } |
310 | local_desc[len] = '\0'; | |
9344e5f5 | 311 | } |
091d0bf3 EB |
312 | |
313 | trace_nbd_receive_list(local_name, local_desc ?: ""); | |
df18c04e | 314 | *name = g_steal_pointer(&local_name); |
091d0bf3 | 315 | if (description) { |
df18c04e | 316 | *description = g_steal_pointer(&local_desc); |
75368aab | 317 | } |
df18c04e | 318 | return 1; |
9344e5f5 DB |
319 | } |
320 | ||
321 | ||
138796d0 EB |
322 | /* |
323 | * nbd_opt_info_or_go: | |
324 | * Send option for NBD_OPT_INFO or NBD_OPT_GO and parse the reply. | |
325 | * Returns -1 if the option proves the export @info->name cannot be | |
326 | * used, 0 if the option is unsupported (fall back to NBD_OPT_LIST and | |
8ecaeae8 | 327 | * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to |
138796d0 EB |
328 | * go (with the rest of @info populated). |
329 | */ | |
330 | static int nbd_opt_info_or_go(QIOChannel *ioc, uint32_t opt, | |
331 | NBDExportInfo *info, Error **errp) | |
8ecaeae8 | 332 | { |
420a4e95 | 333 | NBDOptionReply reply; |
6dc1667d | 334 | uint32_t len = strlen(info->name); |
8ecaeae8 EB |
335 | uint16_t type; |
336 | int error; | |
337 | char *buf; | |
338 | ||
339 | /* The protocol requires that the server send NBD_INFO_EXPORT with | |
340 | * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so | |
341 | * flags still 0 is a witness of a broken server. */ | |
342 | info->flags = 0; | |
343 | ||
138796d0 EB |
344 | assert(opt == NBD_OPT_GO || opt == NBD_OPT_INFO); |
345 | trace_nbd_opt_info_go_start(nbd_opt_lookup(opt), info->name); | |
081dd1fe | 346 | buf = g_malloc(4 + len + 2 + 2 * info->request_sizes + 1); |
8ecaeae8 | 347 | stl_be_p(buf, len); |
6dc1667d | 348 | memcpy(buf + 4, info->name, len); |
081dd1fe EB |
349 | /* At most one request, everything else up to server */ |
350 | stw_be_p(buf + 4 + len, info->request_sizes); | |
351 | if (info->request_sizes) { | |
352 | stw_be_p(buf + 4 + len + 2, NBD_INFO_BLOCK_SIZE); | |
353 | } | |
138796d0 | 354 | error = nbd_send_option_request(ioc, opt, |
158b9aa5 PMD |
355 | 4 + len + 2 + 2 * info->request_sizes, |
356 | buf, errp); | |
357 | g_free(buf); | |
358 | if (error < 0) { | |
8ecaeae8 EB |
359 | return -1; |
360 | } | |
361 | ||
362 | while (1) { | |
138796d0 | 363 | if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) { |
8ecaeae8 EB |
364 | return -1; |
365 | } | |
5de47735 | 366 | error = nbd_handle_reply_err(ioc, &reply, true, errp); |
8ecaeae8 EB |
367 | if (error <= 0) { |
368 | return error; | |
369 | } | |
370 | len = reply.length; | |
371 | ||
372 | if (reply.type == NBD_REP_ACK) { | |
138796d0 EB |
373 | /* |
374 | * Server is done sending info, and moved into transmission | |
375 | * phase for NBD_OPT_GO, but make sure it sent flags | |
376 | */ | |
8ecaeae8 EB |
377 | if (len) { |
378 | error_setg(errp, "server sent invalid NBD_REP_ACK"); | |
8ecaeae8 EB |
379 | return -1; |
380 | } | |
381 | if (!info->flags) { | |
382 | error_setg(errp, "broken server omitted NBD_INFO_EXPORT"); | |
8ecaeae8 EB |
383 | return -1; |
384 | } | |
138796d0 | 385 | trace_nbd_opt_info_go_success(nbd_opt_lookup(opt)); |
8ecaeae8 EB |
386 | return 1; |
387 | } | |
388 | if (reply.type != NBD_REP_INFO) { | |
6c5c0351 EB |
389 | error_setg(errp, "unexpected reply type %u (%s), expected %u (%s)", |
390 | reply.type, nbd_rep_lookup(reply.type), | |
391 | NBD_REP_INFO, nbd_rep_lookup(NBD_REP_INFO)); | |
8ecaeae8 EB |
392 | nbd_send_opt_abort(ioc); |
393 | return -1; | |
394 | } | |
395 | if (len < sizeof(type)) { | |
396 | error_setg(errp, "NBD_REP_INFO length %" PRIu32 " is too short", | |
397 | len); | |
398 | nbd_send_opt_abort(ioc); | |
399 | return -1; | |
400 | } | |
e6798f06 | 401 | if (nbd_read16(ioc, &type, "info type", errp) < 0) { |
8ecaeae8 EB |
402 | nbd_send_opt_abort(ioc); |
403 | return -1; | |
404 | } | |
405 | len -= sizeof(type); | |
8ecaeae8 EB |
406 | switch (type) { |
407 | case NBD_INFO_EXPORT: | |
408 | if (len != sizeof(info->size) + sizeof(info->flags)) { | |
409 | error_setg(errp, "remaining export info len %" PRIu32 | |
410 | " is unexpected size", len); | |
411 | nbd_send_opt_abort(ioc); | |
412 | return -1; | |
413 | } | |
e6798f06 | 414 | if (nbd_read64(ioc, &info->size, "info size", errp) < 0) { |
8ecaeae8 EB |
415 | nbd_send_opt_abort(ioc); |
416 | return -1; | |
417 | } | |
e6798f06 | 418 | if (nbd_read16(ioc, &info->flags, "info flags", errp) < 0) { |
8ecaeae8 EB |
419 | nbd_send_opt_abort(ioc); |
420 | return -1; | |
421 | } | |
3add3ab7 EB |
422 | if (info->min_block && |
423 | !QEMU_IS_ALIGNED(info->size, info->min_block)) { | |
e53f88df | 424 | error_setg(errp, "export size %" PRIu64 " is not multiple of " |
3add3ab7 EB |
425 | "minimum block size %" PRIu32, info->size, |
426 | info->min_block); | |
427 | nbd_send_opt_abort(ioc); | |
428 | return -1; | |
429 | } | |
8ecaeae8 EB |
430 | trace_nbd_receive_negotiate_size_flags(info->size, info->flags); |
431 | break; | |
432 | ||
081dd1fe EB |
433 | case NBD_INFO_BLOCK_SIZE: |
434 | if (len != sizeof(info->min_block) * 3) { | |
435 | error_setg(errp, "remaining export info len %" PRIu32 | |
436 | " is unexpected size", len); | |
437 | nbd_send_opt_abort(ioc); | |
438 | return -1; | |
439 | } | |
e6798f06 VSO |
440 | if (nbd_read32(ioc, &info->min_block, "info minimum block size", |
441 | errp) < 0) { | |
081dd1fe EB |
442 | nbd_send_opt_abort(ioc); |
443 | return -1; | |
444 | } | |
081dd1fe | 445 | if (!is_power_of_2(info->min_block)) { |
e475d108 EB |
446 | error_setg(errp, "server minimum block size %" PRIu32 |
447 | " is not a power of two", info->min_block); | |
081dd1fe EB |
448 | nbd_send_opt_abort(ioc); |
449 | return -1; | |
450 | } | |
e6798f06 VSO |
451 | if (nbd_read32(ioc, &info->opt_block, "info preferred block size", |
452 | errp) < 0) | |
453 | { | |
081dd1fe EB |
454 | nbd_send_opt_abort(ioc); |
455 | return -1; | |
456 | } | |
081dd1fe EB |
457 | if (!is_power_of_2(info->opt_block) || |
458 | info->opt_block < info->min_block) { | |
e475d108 EB |
459 | error_setg(errp, "server preferred block size %" PRIu32 |
460 | " is not valid", info->opt_block); | |
081dd1fe EB |
461 | nbd_send_opt_abort(ioc); |
462 | return -1; | |
463 | } | |
e6798f06 VSO |
464 | if (nbd_read32(ioc, &info->max_block, "info maximum block size", |
465 | errp) < 0) | |
466 | { | |
081dd1fe EB |
467 | nbd_send_opt_abort(ioc); |
468 | return -1; | |
469 | } | |
e475d108 EB |
470 | if (info->max_block < info->min_block) { |
471 | error_setg(errp, "server maximum block size %" PRIu32 | |
472 | " is not valid", info->max_block); | |
473 | nbd_send_opt_abort(ioc); | |
474 | return -1; | |
475 | } | |
138796d0 EB |
476 | trace_nbd_opt_info_block_size(info->min_block, info->opt_block, |
477 | info->max_block); | |
081dd1fe EB |
478 | break; |
479 | ||
8ecaeae8 | 480 | default: |
138796d0 | 481 | trace_nbd_opt_info_unknown(type, nbd_info_lookup(type)); |
8ecaeae8 | 482 | if (nbd_drop(ioc, len, errp) < 0) { |
cb6b1a3f | 483 | error_prepend(errp, "Failed to read info payload: "); |
8ecaeae8 EB |
484 | nbd_send_opt_abort(ioc); |
485 | return -1; | |
486 | } | |
487 | break; | |
488 | } | |
489 | } | |
490 | } | |
491 | ||
75368aab | 492 | /* Return -1 on failure, 0 if wantname is an available export. */ |
9344e5f5 DB |
493 | static int nbd_receive_query_exports(QIOChannel *ioc, |
494 | const char *wantname, | |
495 | Error **errp) | |
496 | { | |
091d0bf3 EB |
497 | bool list_empty = true; |
498 | bool found_export = false; | |
9344e5f5 | 499 | |
9588463e | 500 | trace_nbd_receive_query_exports_start(wantname); |
c8a3a1b6 | 501 | if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) { |
9344e5f5 DB |
502 | return -1; |
503 | } | |
504 | ||
9344e5f5 | 505 | while (1) { |
091d0bf3 EB |
506 | char *name; |
507 | int ret = nbd_receive_list(ioc, &name, NULL, errp); | |
9344e5f5 DB |
508 | |
509 | if (ret < 0) { | |
75368aab | 510 | /* Server gave unexpected reply */ |
9344e5f5 | 511 | return -1; |
75368aab EB |
512 | } else if (ret == 0) { |
513 | /* Done iterating. */ | |
091d0bf3 EB |
514 | if (list_empty) { |
515 | /* | |
516 | * We don't have enough context to tell a server that | |
517 | * sent an empty list apart from a server that does | |
518 | * not support the list command; but as this function | |
519 | * is just used to trigger a nicer error message | |
520 | * before trying NBD_OPT_EXPORT_NAME, assume the | |
521 | * export is available. | |
522 | */ | |
523 | return 0; | |
524 | } else if (!found_export) { | |
75368aab EB |
525 | error_setg(errp, "No export with name '%s' available", |
526 | wantname); | |
527 | nbd_send_opt_abort(ioc); | |
528 | return -1; | |
529 | } | |
9588463e | 530 | trace_nbd_receive_query_exports_success(wantname); |
75368aab | 531 | return 0; |
9344e5f5 | 532 | } |
091d0bf3 EB |
533 | list_empty = false; |
534 | if (!strcmp(name, wantname)) { | |
535 | found_export = true; | |
536 | } | |
537 | g_free(name); | |
9344e5f5 | 538 | } |
9344e5f5 DB |
539 | } |
540 | ||
5de47735 EB |
541 | /* |
542 | * nbd_request_simple_option: Send an option request, and parse the reply. | |
543 | * @strict controls whether ERR_UNSUP or all errors produce 0 status. | |
d795299b VSO |
544 | * return 1 for successful negotiation, |
545 | * 0 if operation is unsupported, | |
546 | * -1 with errp set for any other error | |
547 | */ | |
5de47735 EB |
548 | static int nbd_request_simple_option(QIOChannel *ioc, int opt, bool strict, |
549 | Error **errp) | |
f95910fe | 550 | { |
420a4e95 | 551 | NBDOptionReply reply; |
d795299b | 552 | int error; |
f95910fe | 553 | |
d795299b VSO |
554 | if (nbd_send_option_request(ioc, opt, 0, NULL, errp) < 0) { |
555 | return -1; | |
f95910fe DB |
556 | } |
557 | ||
d795299b VSO |
558 | if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) { |
559 | return -1; | |
560 | } | |
5de47735 | 561 | error = nbd_handle_reply_err(ioc, &reply, strict, errp); |
d795299b VSO |
562 | if (error <= 0) { |
563 | return error; | |
f95910fe | 564 | } |
c8a3a1b6 EB |
565 | |
566 | if (reply.type != NBD_REP_ACK) { | |
d795299b | 567 | error_setg(errp, "Server answered option %d (%s) with unexpected " |
28fb494f | 568 | "reply %" PRIu32 " (%s)", opt, nbd_opt_lookup(opt), |
d795299b | 569 | reply.type, nbd_rep_lookup(reply.type)); |
2cdbf413 | 570 | nbd_send_opt_abort(ioc); |
d795299b | 571 | return -1; |
f95910fe DB |
572 | } |
573 | ||
c8a3a1b6 | 574 | if (reply.length != 0) { |
d795299b VSO |
575 | error_setg(errp, "Option %d ('%s') response length is %" PRIu32 |
576 | " (it should be zero)", opt, nbd_opt_lookup(opt), | |
c8a3a1b6 | 577 | reply.length); |
2cdbf413 | 578 | nbd_send_opt_abort(ioc); |
d795299b VSO |
579 | return -1; |
580 | } | |
581 | ||
582 | return 1; | |
583 | } | |
584 | ||
585 | static QIOChannel *nbd_receive_starttls(QIOChannel *ioc, | |
586 | QCryptoTLSCreds *tlscreds, | |
587 | const char *hostname, Error **errp) | |
588 | { | |
589 | int ret; | |
590 | QIOChannelTLS *tioc; | |
591 | struct NBDTLSHandshakeData data = { 0 }; | |
592 | ||
5de47735 | 593 | ret = nbd_request_simple_option(ioc, NBD_OPT_STARTTLS, true, errp); |
d795299b VSO |
594 | if (ret <= 0) { |
595 | if (ret == 0) { | |
596 | error_setg(errp, "Server don't support STARTTLS option"); | |
597 | nbd_send_opt_abort(ioc); | |
598 | } | |
f95910fe DB |
599 | return NULL; |
600 | } | |
601 | ||
9588463e | 602 | trace_nbd_receive_starttls_new_client(); |
f95910fe DB |
603 | tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp); |
604 | if (!tioc) { | |
605 | return NULL; | |
606 | } | |
0d73f725 | 607 | qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls"); |
f95910fe | 608 | data.loop = g_main_loop_new(g_main_context_default(), FALSE); |
9588463e | 609 | trace_nbd_receive_starttls_tls_handshake(); |
f95910fe DB |
610 | qio_channel_tls_handshake(tioc, |
611 | nbd_tls_handshake, | |
612 | &data, | |
1939ccda | 613 | NULL, |
f95910fe DB |
614 | NULL); |
615 | ||
616 | if (!data.complete) { | |
617 | g_main_loop_run(data.loop); | |
618 | } | |
619 | g_main_loop_unref(data.loop); | |
620 | if (data.error) { | |
621 | error_propagate(errp, data.error); | |
622 | object_unref(OBJECT(tioc)); | |
623 | return NULL; | |
624 | } | |
625 | ||
626 | return QIO_CHANNEL(tioc); | |
627 | } | |
628 | ||
757b3ab9 EB |
629 | /* |
630 | * nbd_send_meta_query: | |
631 | * Send 0 or 1 set/list meta context queries. | |
632 | * Return 0 on success, -1 with errp set for any error | |
633 | */ | |
634 | static int nbd_send_meta_query(QIOChannel *ioc, uint32_t opt, | |
635 | const char *export, const char *query, | |
636 | Error **errp) | |
637 | { | |
638 | int ret; | |
639 | uint32_t export_len = strlen(export); | |
640 | uint32_t queries = !!query; | |
641 | uint32_t query_len = 0; | |
642 | uint32_t data_len; | |
643 | char *data; | |
644 | char *p; | |
645 | ||
646 | data_len = sizeof(export_len) + export_len + sizeof(queries); | |
647 | if (query) { | |
648 | query_len = strlen(query); | |
649 | data_len += sizeof(query_len) + query_len; | |
650 | } else { | |
651 | assert(opt == NBD_OPT_LIST_META_CONTEXT); | |
652 | } | |
653 | p = data = g_malloc(data_len); | |
654 | ||
655 | trace_nbd_opt_meta_request(nbd_opt_lookup(opt), query ?: "(all)", export); | |
656 | stl_be_p(p, export_len); | |
657 | memcpy(p += sizeof(export_len), export, export_len); | |
658 | stl_be_p(p += export_len, queries); | |
659 | if (query) { | |
660 | stl_be_p(p += sizeof(queries), query_len); | |
661 | memcpy(p += sizeof(query_len), query, query_len); | |
662 | } | |
663 | ||
664 | ret = nbd_send_option_request(ioc, opt, data_len, data, errp); | |
665 | g_free(data); | |
666 | return ret; | |
667 | } | |
668 | ||
0182c1ae EB |
669 | /* |
670 | * nbd_receive_one_meta_context: | |
671 | * Called in a loop to receive and trace one set/list meta context reply. | |
672 | * Pass non-NULL @name or @id to collect results back to the caller, which | |
673 | * must eventually call g_free(). | |
674 | * return 1 if name is set and iteration must continue, | |
675 | * 0 if iteration is complete (including if option is unsupported), | |
676 | * -1 with errp set for any error | |
677 | */ | |
678 | static int nbd_receive_one_meta_context(QIOChannel *ioc, | |
679 | uint32_t opt, | |
680 | char **name, | |
681 | uint32_t *id, | |
682 | Error **errp) | |
683 | { | |
684 | int ret; | |
685 | NBDOptionReply reply; | |
686 | char *local_name = NULL; | |
687 | uint32_t local_id; | |
688 | ||
689 | if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) { | |
690 | return -1; | |
691 | } | |
692 | ||
5de47735 | 693 | ret = nbd_handle_reply_err(ioc, &reply, false, errp); |
0182c1ae EB |
694 | if (ret <= 0) { |
695 | return ret; | |
696 | } | |
697 | ||
698 | if (reply.type == NBD_REP_ACK) { | |
699 | if (reply.length != 0) { | |
700 | error_setg(errp, "Unexpected length to ACK response"); | |
701 | nbd_send_opt_abort(ioc); | |
702 | return -1; | |
703 | } | |
704 | return 0; | |
705 | } else if (reply.type != NBD_REP_META_CONTEXT) { | |
706 | error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)", | |
707 | reply.type, nbd_rep_lookup(reply.type), | |
708 | NBD_REP_META_CONTEXT, nbd_rep_lookup(NBD_REP_META_CONTEXT)); | |
709 | nbd_send_opt_abort(ioc); | |
710 | return -1; | |
711 | } | |
712 | ||
713 | if (reply.length <= sizeof(local_id) || | |
714 | reply.length > NBD_MAX_BUFFER_SIZE) { | |
715 | error_setg(errp, "Failed to negotiate meta context, server " | |
716 | "answered with unexpected length %" PRIu32, | |
717 | reply.length); | |
718 | nbd_send_opt_abort(ioc); | |
719 | return -1; | |
720 | } | |
721 | ||
e6798f06 | 722 | if (nbd_read32(ioc, &local_id, "context id", errp) < 0) { |
0182c1ae EB |
723 | return -1; |
724 | } | |
0182c1ae EB |
725 | |
726 | reply.length -= sizeof(local_id); | |
727 | local_name = g_malloc(reply.length + 1); | |
e6798f06 | 728 | if (nbd_read(ioc, local_name, reply.length, "context name", errp) < 0) { |
0182c1ae EB |
729 | g_free(local_name); |
730 | return -1; | |
731 | } | |
732 | local_name[reply.length] = '\0'; | |
733 | trace_nbd_opt_meta_reply(nbd_opt_lookup(opt), local_name, local_id); | |
734 | ||
735 | if (name) { | |
736 | *name = local_name; | |
737 | } else { | |
738 | g_free(local_name); | |
739 | } | |
740 | if (id) { | |
741 | *id = local_id; | |
742 | } | |
743 | return 1; | |
744 | } | |
745 | ||
746 | /* | |
747 | * nbd_negotiate_simple_meta_context: | |
2df94eb5 EB |
748 | * Request the server to set the meta context for export @info->name |
749 | * using @info->x_dirty_bitmap with a fallback to "base:allocation", | |
750 | * setting @info->context_id to the resulting id. Fail if the server | |
751 | * responds with more than one context or with a context different | |
752 | * than the query. | |
753 | * return 1 for successful negotiation, | |
78a33ab5 VSO |
754 | * 0 if operation is unsupported, |
755 | * -1 with errp set for any other error | |
756 | */ | |
757 | static int nbd_negotiate_simple_meta_context(QIOChannel *ioc, | |
2df94eb5 | 758 | NBDExportInfo *info, |
78a33ab5 VSO |
759 | Error **errp) |
760 | { | |
2df94eb5 EB |
761 | /* |
762 | * TODO: Removing the x_dirty_bitmap hack will mean refactoring | |
763 | * this function to request and store ids for multiple contexts | |
764 | * (both base:allocation and a dirty bitmap), at which point this | |
765 | * function should lose the term _simple. | |
766 | */ | |
78a33ab5 | 767 | int ret; |
2df94eb5 | 768 | const char *context = info->x_dirty_bitmap ?: "base:allocation"; |
89aa0d87 | 769 | bool received = false; |
0182c1ae | 770 | char *name = NULL; |
78a33ab5 | 771 | |
757b3ab9 EB |
772 | if (nbd_send_meta_query(ioc, NBD_OPT_SET_META_CONTEXT, |
773 | info->name, context, errp) < 0) { | |
774 | return -1; | |
78a33ab5 VSO |
775 | } |
776 | ||
0182c1ae EB |
777 | ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT, |
778 | &name, &info->context_id, errp); | |
779 | if (ret < 0) { | |
78a33ab5 VSO |
780 | return -1; |
781 | } | |
0182c1ae | 782 | if (ret == 1) { |
78a33ab5 VSO |
783 | if (strcmp(context, name)) { |
784 | error_setg(errp, "Failed to negotiate meta context '%s', server " | |
785 | "answered with different context '%s'", context, | |
786 | name); | |
787 | g_free(name); | |
260e34db | 788 | nbd_send_opt_abort(ioc); |
78a33ab5 VSO |
789 | return -1; |
790 | } | |
791 | g_free(name); | |
78a33ab5 VSO |
792 | received = true; |
793 | ||
0182c1ae EB |
794 | ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT, |
795 | NULL, NULL, errp); | |
796 | if (ret < 0) { | |
78a33ab5 VSO |
797 | return -1; |
798 | } | |
78a33ab5 | 799 | } |
0182c1ae EB |
800 | if (ret != 0) { |
801 | error_setg(errp, "Server answered with more than one context"); | |
260e34db EB |
802 | nbd_send_opt_abort(ioc); |
803 | return -1; | |
804 | } | |
2df94eb5 | 805 | return received; |
78a33ab5 | 806 | } |
f95910fe | 807 | |
0b576b6b EB |
808 | /* |
809 | * nbd_list_meta_contexts: | |
810 | * Request the server to list all meta contexts for export @info->name. | |
811 | * return 0 if list is complete (even if empty), | |
812 | * -1 with errp set for any error | |
813 | */ | |
814 | static int nbd_list_meta_contexts(QIOChannel *ioc, | |
815 | NBDExportInfo *info, | |
816 | Error **errp) | |
817 | { | |
818 | int ret; | |
7c6f5ddc EB |
819 | int seen_any = false; |
820 | int seen_qemu = false; | |
0b576b6b EB |
821 | |
822 | if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT, | |
823 | info->name, NULL, errp) < 0) { | |
824 | return -1; | |
825 | } | |
826 | ||
827 | while (1) { | |
828 | char *context; | |
829 | ||
830 | ret = nbd_receive_one_meta_context(ioc, NBD_OPT_LIST_META_CONTEXT, | |
831 | &context, NULL, errp); | |
7c6f5ddc EB |
832 | if (ret == 0 && seen_any && !seen_qemu) { |
833 | /* | |
834 | * Work around qemu 3.0 bug: the server forgot to send | |
835 | * "qemu:" replies to 0 queries. If we saw at least one | |
836 | * reply (probably base:allocation), but none of them were | |
837 | * qemu:, then run a more specific query to make sure. | |
838 | */ | |
839 | seen_qemu = true; | |
840 | if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT, | |
841 | info->name, "qemu:", errp) < 0) { | |
842 | return -1; | |
843 | } | |
844 | continue; | |
845 | } | |
0b576b6b EB |
846 | if (ret <= 0) { |
847 | return ret; | |
848 | } | |
7c6f5ddc EB |
849 | seen_any = true; |
850 | seen_qemu |= strstart(context, "qemu:", NULL); | |
0b576b6b EB |
851 | info->contexts = g_renew(char *, info->contexts, ++info->n_contexts); |
852 | info->contexts[info->n_contexts - 1] = context; | |
853 | } | |
854 | } | |
855 | ||
10b89988 EB |
856 | /* |
857 | * nbd_start_negotiate: | |
858 | * Start the handshake to the server. After a positive return, the server | |
859 | * is ready to accept additional NBD_OPT requests. | |
860 | * Returns: negative errno: failure talking to server | |
b3c9d33b | 861 | * 0: server is oldstyle, must call nbd_negotiate_finish_oldstyle |
10b89988 EB |
862 | * 1: server is newstyle, but can only accept EXPORT_NAME |
863 | * 2: server is newstyle, but lacks structured replies | |
864 | * 3: server is newstyle and set up for structured replies | |
865 | */ | |
a8e2bb6a VSO |
866 | static int nbd_start_negotiate(AioContext *aio_context, QIOChannel *ioc, |
867 | QCryptoTLSCreds *tlscreds, | |
10b89988 EB |
868 | const char *hostname, QIOChannel **outioc, |
869 | bool structured_reply, bool *zeroes, | |
870 | Error **errp) | |
798bfe00 | 871 | { |
004a89fc | 872 | uint64_t magic; |
798bfe00 | 873 | |
10b89988 | 874 | trace_nbd_start_negotiate(tlscreds, hostname ? hostname : "<null>"); |
798bfe00 | 875 | |
d21a2d34 EB |
876 | if (zeroes) { |
877 | *zeroes = true; | |
878 | } | |
f95910fe DB |
879 | if (outioc) { |
880 | *outioc = NULL; | |
881 | } | |
882 | if (tlscreds && !outioc) { | |
883 | error_setg(errp, "Output I/O channel required for TLS"); | |
2b8d0954 | 884 | return -EINVAL; |
f95910fe DB |
885 | } |
886 | ||
e6798f06 | 887 | if (nbd_read64(ioc, &magic, "initial magic", errp) < 0) { |
2b8d0954 | 888 | return -EINVAL; |
798bfe00 | 889 | } |
9588463e | 890 | trace_nbd_receive_negotiate_magic(magic); |
798bfe00 | 891 | |
ef2e35fc EB |
892 | if (magic != NBD_INIT_MAGIC) { |
893 | error_setg(errp, "Bad initial magic received: 0x%" PRIx64, magic); | |
2b8d0954 | 894 | return -EINVAL; |
798bfe00 FZ |
895 | } |
896 | ||
e6798f06 | 897 | if (nbd_read64(ioc, &magic, "server magic", errp) < 0) { |
2b8d0954 | 898 | return -EINVAL; |
798bfe00 | 899 | } |
9588463e | 900 | trace_nbd_receive_negotiate_magic(magic); |
798bfe00 | 901 | |
f72d705f | 902 | if (magic == NBD_OPTS_MAGIC) { |
e2a9d9a3 | 903 | uint32_t clientflags = 0; |
e2a9d9a3 | 904 | uint16_t globalflags; |
9344e5f5 | 905 | bool fixedNewStyle = false; |
798bfe00 | 906 | |
e6798f06 | 907 | if (nbd_read16(ioc, &globalflags, "server flags", errp) < 0) { |
2b8d0954 | 908 | return -EINVAL; |
798bfe00 | 909 | } |
9588463e | 910 | trace_nbd_receive_negotiate_server_flags(globalflags); |
e2a9d9a3 | 911 | if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) { |
9344e5f5 | 912 | fixedNewStyle = true; |
e2a9d9a3 DB |
913 | clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE; |
914 | } | |
c203c59a | 915 | if (globalflags & NBD_FLAG_NO_ZEROES) { |
d21a2d34 EB |
916 | if (zeroes) { |
917 | *zeroes = false; | |
918 | } | |
c203c59a EB |
919 | clientflags |= NBD_FLAG_C_NO_ZEROES; |
920 | } | |
e2a9d9a3 | 921 | /* client requested flags */ |
9344e5f5 | 922 | clientflags = cpu_to_be32(clientflags); |
d1fdf257 | 923 | if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) { |
cb6b1a3f | 924 | error_prepend(errp, "Failed to send clientflags field: "); |
2b8d0954 | 925 | return -EINVAL; |
798bfe00 | 926 | } |
f95910fe DB |
927 | if (tlscreds) { |
928 | if (fixedNewStyle) { | |
929 | *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp); | |
930 | if (!*outioc) { | |
2b8d0954 | 931 | return -EINVAL; |
f95910fe DB |
932 | } |
933 | ioc = *outioc; | |
a8e2bb6a VSO |
934 | if (aio_context) { |
935 | qio_channel_set_blocking(ioc, false, NULL); | |
936 | qio_channel_attach_aio_context(ioc, aio_context); | |
937 | } | |
f95910fe DB |
938 | } else { |
939 | error_setg(errp, "Server does not support STARTTLS"); | |
2b8d0954 | 940 | return -EINVAL; |
f95910fe DB |
941 | } |
942 | } | |
9344e5f5 | 943 | if (fixedNewStyle) { |
10b89988 | 944 | int result = 0; |
8ecaeae8 | 945 | |
f140e300 VSO |
946 | if (structured_reply) { |
947 | result = nbd_request_simple_option(ioc, | |
948 | NBD_OPT_STRUCTURED_REPLY, | |
5de47735 | 949 | false, errp); |
f140e300 | 950 | if (result < 0) { |
2b8d0954 | 951 | return -EINVAL; |
f140e300 | 952 | } |
f140e300 | 953 | } |
10b89988 EB |
954 | return 2 + result; |
955 | } else { | |
956 | return 1; | |
957 | } | |
958 | } else if (magic == NBD_CLIENT_MAGIC) { | |
959 | if (tlscreds) { | |
960 | error_setg(errp, "Server does not support STARTTLS"); | |
961 | return -EINVAL; | |
962 | } | |
963 | return 0; | |
964 | } else { | |
965 | error_setg(errp, "Bad server magic received: 0x%" PRIx64, magic); | |
966 | return -EINVAL; | |
967 | } | |
968 | } | |
f140e300 | 969 | |
b3c9d33b EB |
970 | /* |
971 | * nbd_negotiate_finish_oldstyle: | |
972 | * Populate @info with the size and export flags from an oldstyle server, | |
973 | * but does not consume 124 bytes of reserved zero padding. | |
974 | * Returns 0 on success, -1 with @errp set on failure | |
975 | */ | |
976 | static int nbd_negotiate_finish_oldstyle(QIOChannel *ioc, NBDExportInfo *info, | |
977 | Error **errp) | |
978 | { | |
979 | uint32_t oldflags; | |
980 | ||
e6798f06 | 981 | if (nbd_read64(ioc, &info->size, "export length", errp) < 0) { |
b3c9d33b EB |
982 | return -EINVAL; |
983 | } | |
b3c9d33b | 984 | |
e6798f06 | 985 | if (nbd_read32(ioc, &oldflags, "export flags", errp) < 0) { |
b3c9d33b EB |
986 | return -EINVAL; |
987 | } | |
b3c9d33b EB |
988 | if (oldflags & ~0xffff) { |
989 | error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags); | |
990 | return -EINVAL; | |
991 | } | |
992 | info->flags = oldflags; | |
993 | return 0; | |
994 | } | |
995 | ||
10b89988 EB |
996 | /* |
997 | * nbd_receive_negotiate: | |
998 | * Connect to server, complete negotiation, and move into transmission phase. | |
999 | * Returns: negative errno: failure talking to server | |
1000 | * 0: server is connected | |
1001 | */ | |
a8e2bb6a VSO |
1002 | int nbd_receive_negotiate(AioContext *aio_context, QIOChannel *ioc, |
1003 | QCryptoTLSCreds *tlscreds, | |
10b89988 EB |
1004 | const char *hostname, QIOChannel **outioc, |
1005 | NBDExportInfo *info, Error **errp) | |
1006 | { | |
1007 | int result; | |
1008 | bool zeroes; | |
1009 | bool base_allocation = info->base_allocation; | |
78a33ab5 | 1010 | |
10b89988 EB |
1011 | assert(info->name); |
1012 | trace_nbd_receive_negotiate_name(info->name); | |
1013 | ||
a8e2bb6a | 1014 | result = nbd_start_negotiate(aio_context, ioc, tlscreds, hostname, outioc, |
10b89988 EB |
1015 | info->structured_reply, &zeroes, errp); |
1016 | ||
1017 | info->structured_reply = false; | |
1018 | info->base_allocation = false; | |
1019 | if (tlscreds && *outioc) { | |
1020 | ioc = *outioc; | |
1021 | } | |
1022 | ||
1023 | switch (result) { | |
1024 | case 3: /* newstyle, with structured replies */ | |
1025 | info->structured_reply = true; | |
1026 | if (base_allocation) { | |
1027 | result = nbd_negotiate_simple_meta_context(ioc, info, errp); | |
8ecaeae8 | 1028 | if (result < 0) { |
2b8d0954 | 1029 | return -EINVAL; |
8ecaeae8 | 1030 | } |
10b89988 EB |
1031 | info->base_allocation = result == 1; |
1032 | } | |
1033 | /* fall through */ | |
1034 | case 2: /* newstyle, try OPT_GO */ | |
1035 | /* Try NBD_OPT_GO first - if it works, we are done (it | |
1036 | * also gives us a good message if the server requires | |
1037 | * TLS). If it is not available, fall back to | |
1038 | * NBD_OPT_LIST for nicer error messages about a missing | |
1039 | * export, then use NBD_OPT_EXPORT_NAME. */ | |
138796d0 | 1040 | result = nbd_opt_info_or_go(ioc, NBD_OPT_GO, info, errp); |
10b89988 EB |
1041 | if (result < 0) { |
1042 | return -EINVAL; | |
9344e5f5 | 1043 | } |
10b89988 EB |
1044 | if (result > 0) { |
1045 | return 0; | |
1046 | } | |
1047 | /* Check our desired export is present in the | |
1048 | * server export list. Since NBD_OPT_EXPORT_NAME | |
1049 | * cannot return an error message, running this | |
1050 | * query gives us better error reporting if the | |
1051 | * export name is not available. | |
1052 | */ | |
1053 | if (nbd_receive_query_exports(ioc, info->name, errp) < 0) { | |
1054 | return -EINVAL; | |
1055 | } | |
1056 | /* fall through */ | |
1057 | case 1: /* newstyle, but limited to EXPORT_NAME */ | |
c8a3a1b6 | 1058 | /* write the export name request */ |
6dc1667d | 1059 | if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, info->name, |
c8a3a1b6 | 1060 | errp) < 0) { |
2b8d0954 | 1061 | return -EINVAL; |
798bfe00 | 1062 | } |
f72d705f | 1063 | |
c8a3a1b6 | 1064 | /* Read the response */ |
e6798f06 | 1065 | if (nbd_read64(ioc, &info->size, "export length", errp) < 0) { |
2b8d0954 | 1066 | return -EINVAL; |
798bfe00 | 1067 | } |
798bfe00 | 1068 | |
e6798f06 | 1069 | if (nbd_read16(ioc, &info->flags, "export flags", errp) < 0) { |
2b8d0954 | 1070 | return -EINVAL; |
f72d705f | 1071 | } |
10b89988 EB |
1072 | break; |
1073 | case 0: /* oldstyle, parse length and flags */ | |
6dc1667d EB |
1074 | if (*info->name) { |
1075 | error_setg(errp, "Server does not support non-empty export names"); | |
2b8d0954 | 1076 | return -EINVAL; |
f72d705f | 1077 | } |
b3c9d33b | 1078 | if (nbd_negotiate_finish_oldstyle(ioc, info, errp) < 0) { |
2b8d0954 | 1079 | return -EINVAL; |
7423f417 | 1080 | } |
10b89988 EB |
1081 | break; |
1082 | default: | |
1083 | return result; | |
798bfe00 | 1084 | } |
f72d705f | 1085 | |
004a89fc | 1086 | trace_nbd_receive_negotiate_size_flags(info->size, info->flags); |
d1fdf257 | 1087 | if (zeroes && nbd_drop(ioc, 124, errp) < 0) { |
cb6b1a3f | 1088 | error_prepend(errp, "Failed to read reserved block: "); |
2b8d0954 | 1089 | return -EINVAL; |
798bfe00 | 1090 | } |
2b8d0954 | 1091 | return 0; |
798bfe00 FZ |
1092 | } |
1093 | ||
d21a2d34 EB |
1094 | /* Clean up result of nbd_receive_export_list */ |
1095 | void nbd_free_export_list(NBDExportInfo *info, int count) | |
1096 | { | |
0b576b6b | 1097 | int i, j; |
d21a2d34 EB |
1098 | |
1099 | if (!info) { | |
1100 | return; | |
1101 | } | |
1102 | ||
1103 | for (i = 0; i < count; i++) { | |
1104 | g_free(info[i].name); | |
1105 | g_free(info[i].description); | |
0b576b6b EB |
1106 | for (j = 0; j < info[i].n_contexts; j++) { |
1107 | g_free(info[i].contexts[j]); | |
1108 | } | |
1109 | g_free(info[i].contexts); | |
d21a2d34 EB |
1110 | } |
1111 | g_free(info); | |
1112 | } | |
1113 | ||
1114 | /* | |
1115 | * nbd_receive_export_list: | |
1116 | * Query details about a server's exports, then disconnect without | |
1117 | * going into transmission phase. Return a count of the exports listed | |
1118 | * in @info by the server, or -1 on error. Caller must free @info using | |
1119 | * nbd_free_export_list(). | |
1120 | */ | |
1121 | int nbd_receive_export_list(QIOChannel *ioc, QCryptoTLSCreds *tlscreds, | |
1122 | const char *hostname, NBDExportInfo **info, | |
1123 | Error **errp) | |
1124 | { | |
1125 | int result; | |
1126 | int count = 0; | |
1127 | int i; | |
1128 | int rc; | |
1129 | int ret = -1; | |
1130 | NBDExportInfo *array = NULL; | |
1131 | QIOChannel *sioc = NULL; | |
1132 | ||
1133 | *info = NULL; | |
a8e2bb6a VSO |
1134 | result = nbd_start_negotiate(NULL, ioc, tlscreds, hostname, &sioc, true, |
1135 | NULL, errp); | |
d21a2d34 EB |
1136 | if (tlscreds && sioc) { |
1137 | ioc = sioc; | |
1138 | } | |
1139 | ||
1140 | switch (result) { | |
1141 | case 2: | |
1142 | case 3: | |
1143 | /* newstyle - use NBD_OPT_LIST to populate array, then try | |
1144 | * NBD_OPT_INFO on each array member. If structured replies | |
1145 | * are enabled, also try NBD_OPT_LIST_META_CONTEXT. */ | |
1146 | if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) { | |
1147 | goto out; | |
1148 | } | |
1149 | while (1) { | |
1150 | char *name; | |
1151 | char *desc; | |
1152 | ||
1153 | rc = nbd_receive_list(ioc, &name, &desc, errp); | |
1154 | if (rc < 0) { | |
1155 | goto out; | |
1156 | } else if (rc == 0) { | |
1157 | break; | |
1158 | } | |
1159 | array = g_renew(NBDExportInfo, array, ++count); | |
1160 | memset(&array[count - 1], 0, sizeof(*array)); | |
1161 | array[count - 1].name = name; | |
1162 | array[count - 1].description = desc; | |
1163 | array[count - 1].structured_reply = result == 3; | |
1164 | } | |
1165 | ||
1166 | for (i = 0; i < count; i++) { | |
1167 | array[i].request_sizes = true; | |
1168 | rc = nbd_opt_info_or_go(ioc, NBD_OPT_INFO, &array[i], errp); | |
1169 | if (rc < 0) { | |
1170 | goto out; | |
1171 | } else if (rc == 0) { | |
1172 | /* | |
1173 | * Pointless to try rest of loop. If OPT_INFO doesn't work, | |
1174 | * it's unlikely that meta contexts work either | |
1175 | */ | |
1176 | break; | |
1177 | } | |
1178 | ||
0b576b6b EB |
1179 | if (result == 3 && |
1180 | nbd_list_meta_contexts(ioc, &array[i], errp) < 0) { | |
1181 | goto out; | |
1182 | } | |
d21a2d34 EB |
1183 | } |
1184 | ||
1185 | /* Send NBD_OPT_ABORT as a courtesy before hanging up */ | |
1186 | nbd_send_opt_abort(ioc); | |
1187 | break; | |
1188 | case 1: /* newstyle, but limited to EXPORT_NAME */ | |
1189 | error_setg(errp, "Server does not support export lists"); | |
1190 | /* We can't even send NBD_OPT_ABORT, so merely hang up */ | |
1191 | goto out; | |
1192 | case 0: /* oldstyle, parse length and flags */ | |
1193 | array = g_new0(NBDExportInfo, 1); | |
1194 | array->name = g_strdup(""); | |
1195 | count = 1; | |
1196 | ||
1197 | if (nbd_negotiate_finish_oldstyle(ioc, array, errp) < 0) { | |
1198 | goto out; | |
1199 | } | |
1200 | ||
1201 | /* Send NBD_CMD_DISC as a courtesy to the server, but ignore all | |
1202 | * errors now that we have the information we wanted. */ | |
1203 | if (nbd_drop(ioc, 124, NULL) == 0) { | |
1204 | NBDRequest request = { .type = NBD_CMD_DISC }; | |
1205 | ||
1206 | nbd_send_request(ioc, &request); | |
1207 | } | |
1208 | break; | |
1209 | default: | |
1210 | goto out; | |
1211 | } | |
1212 | ||
1213 | *info = array; | |
1214 | array = NULL; | |
1215 | ret = count; | |
1216 | ||
1217 | out: | |
1218 | qio_channel_shutdown(ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL); | |
1219 | qio_channel_close(ioc, NULL); | |
1220 | object_unref(OBJECT(sioc)); | |
1221 | nbd_free_export_list(array, count); | |
1222 | return ret; | |
1223 | } | |
1224 | ||
798bfe00 | 1225 | #ifdef __linux__ |
004a89fc | 1226 | int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info, |
be41c100 | 1227 | Error **errp) |
798bfe00 | 1228 | { |
081dd1fe EB |
1229 | unsigned long sector_size = MAX(BDRV_SECTOR_SIZE, info->min_block); |
1230 | unsigned long sectors = info->size / sector_size; | |
1231 | ||
1232 | /* FIXME: Once the kernel module is patched to honor block sizes, | |
1233 | * and to advertise that fact to user space, we should update the | |
1234 | * hand-off to the kernel to use any block sizes we learned. */ | |
1235 | assert(!info->request_sizes); | |
1236 | if (info->size / sector_size != sectors) { | |
004a89fc EB |
1237 | error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel", |
1238 | info->size); | |
f57e2416 EB |
1239 | return -E2BIG; |
1240 | } | |
1241 | ||
9588463e | 1242 | trace_nbd_init_set_socket(); |
798bfe00 | 1243 | |
f57e2416 | 1244 | if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) { |
798bfe00 | 1245 | int serrno = errno; |
be41c100 | 1246 | error_setg(errp, "Failed to set NBD socket"); |
798bfe00 FZ |
1247 | return -serrno; |
1248 | } | |
1249 | ||
081dd1fe | 1250 | trace_nbd_init_set_block_size(sector_size); |
798bfe00 | 1251 | |
081dd1fe | 1252 | if (ioctl(fd, NBD_SET_BLKSIZE, sector_size) < 0) { |
798bfe00 | 1253 | int serrno = errno; |
be41c100 | 1254 | error_setg(errp, "Failed setting NBD block size"); |
798bfe00 FZ |
1255 | return -serrno; |
1256 | } | |
1257 | ||
9588463e | 1258 | trace_nbd_init_set_size(sectors); |
081dd1fe EB |
1259 | if (info->size % sector_size) { |
1260 | trace_nbd_init_trailing_bytes(info->size % sector_size); | |
f57e2416 | 1261 | } |
798bfe00 | 1262 | |
f57e2416 | 1263 | if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) { |
798bfe00 | 1264 | int serrno = errno; |
be41c100 | 1265 | error_setg(errp, "Failed setting size (in blocks)"); |
798bfe00 FZ |
1266 | return -serrno; |
1267 | } | |
1268 | ||
004a89fc | 1269 | if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) { |
798bfe00 | 1270 | if (errno == ENOTTY) { |
004a89fc | 1271 | int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0; |
9588463e | 1272 | trace_nbd_init_set_readonly(); |
798bfe00 FZ |
1273 | |
1274 | if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) { | |
1275 | int serrno = errno; | |
be41c100 | 1276 | error_setg(errp, "Failed setting read-only attribute"); |
798bfe00 FZ |
1277 | return -serrno; |
1278 | } | |
1279 | } else { | |
1280 | int serrno = errno; | |
be41c100 | 1281 | error_setg(errp, "Failed setting flags"); |
798bfe00 FZ |
1282 | return -serrno; |
1283 | } | |
1284 | } | |
1285 | ||
9588463e | 1286 | trace_nbd_init_finish(); |
798bfe00 FZ |
1287 | |
1288 | return 0; | |
1289 | } | |
1290 | ||
1291 | int nbd_client(int fd) | |
1292 | { | |
1293 | int ret; | |
1294 | int serrno; | |
1295 | ||
9588463e | 1296 | trace_nbd_client_loop(); |
798bfe00 FZ |
1297 | |
1298 | ret = ioctl(fd, NBD_DO_IT); | |
1299 | if (ret < 0 && errno == EPIPE) { | |
1300 | /* NBD_DO_IT normally returns EPIPE when someone has disconnected | |
1301 | * the socket via NBD_DISCONNECT. We do not want to return 1 in | |
1302 | * that case. | |
1303 | */ | |
1304 | ret = 0; | |
1305 | } | |
1306 | serrno = errno; | |
1307 | ||
9588463e | 1308 | trace_nbd_client_loop_ret(ret, strerror(serrno)); |
798bfe00 | 1309 | |
9588463e | 1310 | trace_nbd_client_clear_queue(); |
798bfe00 FZ |
1311 | ioctl(fd, NBD_CLEAR_QUE); |
1312 | ||
9588463e | 1313 | trace_nbd_client_clear_socket(); |
798bfe00 FZ |
1314 | ioctl(fd, NBD_CLEAR_SOCK); |
1315 | ||
1316 | errno = serrno; | |
1317 | return ret; | |
1318 | } | |
98494e3b EB |
1319 | |
1320 | int nbd_disconnect(int fd) | |
1321 | { | |
1322 | ioctl(fd, NBD_CLEAR_QUE); | |
1323 | ioctl(fd, NBD_DISCONNECT); | |
1324 | ioctl(fd, NBD_CLEAR_SOCK); | |
1325 | return 0; | |
1326 | } | |
1327 | ||
3c1fa35d | 1328 | #endif /* __linux__ */ |
798bfe00 | 1329 | |
490dc5ed | 1330 | int nbd_send_request(QIOChannel *ioc, NBDRequest *request) |
798bfe00 FZ |
1331 | { |
1332 | uint8_t buf[NBD_REQUEST_SIZE]; | |
798bfe00 | 1333 | |
9588463e | 1334 | trace_nbd_send_request(request->from, request->len, request->handle, |
48000eb3 EB |
1335 | request->flags, request->type, |
1336 | nbd_cmd_lookup(request->type)); | |
7548fe31 | 1337 | |
f6be6720 | 1338 | stl_be_p(buf, NBD_REQUEST_MAGIC); |
b626b51a EB |
1339 | stw_be_p(buf + 4, request->flags); |
1340 | stw_be_p(buf + 6, request->type); | |
f6be6720 PM |
1341 | stq_be_p(buf + 8, request->handle); |
1342 | stq_be_p(buf + 16, request->from); | |
1343 | stl_be_p(buf + 24, request->len); | |
798bfe00 | 1344 | |
d1fdf257 | 1345 | return nbd_write(ioc, buf, sizeof(buf), NULL); |
798bfe00 FZ |
1346 | } |
1347 | ||
d2febedb VSO |
1348 | /* nbd_receive_simple_reply |
1349 | * Read simple reply except magic field (which should be already read). | |
1350 | * Payload is not read (payload is possible for CMD_READ, but here we even | |
1351 | * don't know whether it take place or not). | |
1352 | */ | |
1353 | static int nbd_receive_simple_reply(QIOChannel *ioc, NBDSimpleReply *reply, | |
1354 | Error **errp) | |
1355 | { | |
1356 | int ret; | |
1357 | ||
1358 | assert(reply->magic == NBD_SIMPLE_REPLY_MAGIC); | |
1359 | ||
1360 | ret = nbd_read(ioc, (uint8_t *)reply + sizeof(reply->magic), | |
e6798f06 | 1361 | sizeof(*reply) - sizeof(reply->magic), "reply", errp); |
d2febedb VSO |
1362 | if (ret < 0) { |
1363 | return ret; | |
1364 | } | |
1365 | ||
80c7c2b0 PM |
1366 | reply->error = be32_to_cpu(reply->error); |
1367 | reply->handle = be64_to_cpu(reply->handle); | |
d2febedb VSO |
1368 | |
1369 | return 0; | |
1370 | } | |
1371 | ||
1372 | /* nbd_receive_structured_reply_chunk | |
1373 | * Read structured reply chunk except magic field (which should be already | |
1374 | * read). | |
1375 | * Payload is not read. | |
1376 | */ | |
1377 | static int nbd_receive_structured_reply_chunk(QIOChannel *ioc, | |
1378 | NBDStructuredReplyChunk *chunk, | |
1379 | Error **errp) | |
1380 | { | |
1381 | int ret; | |
1382 | ||
1383 | assert(chunk->magic == NBD_STRUCTURED_REPLY_MAGIC); | |
1384 | ||
1385 | ret = nbd_read(ioc, (uint8_t *)chunk + sizeof(chunk->magic), | |
e6798f06 VSO |
1386 | sizeof(*chunk) - sizeof(chunk->magic), "structured chunk", |
1387 | errp); | |
d2febedb VSO |
1388 | if (ret < 0) { |
1389 | return ret; | |
1390 | } | |
1391 | ||
80c7c2b0 PM |
1392 | chunk->flags = be16_to_cpu(chunk->flags); |
1393 | chunk->type = be16_to_cpu(chunk->type); | |
1394 | chunk->handle = be64_to_cpu(chunk->handle); | |
1395 | chunk->length = be32_to_cpu(chunk->length); | |
d2febedb VSO |
1396 | |
1397 | return 0; | |
1398 | } | |
1399 | ||
a7b78fc9 KW |
1400 | /* nbd_read_eof |
1401 | * Tries to read @size bytes from @ioc. | |
1402 | * Returns 1 on success | |
1403 | * 0 on eof, when no data was read (errp is not set) | |
1404 | * negative errno on failure (errp is set) | |
1405 | */ | |
1406 | static inline int coroutine_fn | |
d3bd5b90 KW |
1407 | nbd_read_eof(BlockDriverState *bs, QIOChannel *ioc, void *buffer, size_t size, |
1408 | Error **errp) | |
a7b78fc9 | 1409 | { |
d3bd5b90 | 1410 | bool partial = false; |
a7b78fc9 KW |
1411 | |
1412 | assert(size); | |
d3bd5b90 KW |
1413 | while (size > 0) { |
1414 | struct iovec iov = { .iov_base = buffer, .iov_len = size }; | |
1415 | ssize_t len; | |
1416 | ||
1417 | len = qio_channel_readv(ioc, &iov, 1, errp); | |
1418 | if (len == QIO_CHANNEL_ERR_BLOCK) { | |
1419 | bdrv_dec_in_flight(bs); | |
1420 | qio_channel_yield(ioc, G_IO_IN); | |
1421 | bdrv_inc_in_flight(bs); | |
1422 | continue; | |
1423 | } else if (len < 0) { | |
1424 | return -EIO; | |
1425 | } else if (len == 0) { | |
1426 | if (partial) { | |
1427 | error_setg(errp, | |
1428 | "Unexpected end-of-file before all bytes were read"); | |
1429 | return -EIO; | |
1430 | } else { | |
1431 | return 0; | |
1432 | } | |
1433 | } | |
1434 | ||
1435 | partial = true; | |
1436 | size -= len; | |
1437 | buffer = (uint8_t*) buffer + len; | |
a7b78fc9 | 1438 | } |
d3bd5b90 | 1439 | return 1; |
a7b78fc9 KW |
1440 | } |
1441 | ||
ba845644 | 1442 | /* nbd_receive_reply |
d3bd5b90 KW |
1443 | * |
1444 | * Decreases bs->in_flight while waiting for a new reply. This yield is where | |
1445 | * we wait indefinitely and the coroutine must be able to be safely reentered | |
1446 | * for nbd_client_attach_aio_context(). | |
1447 | * | |
ba845644 VSO |
1448 | * Returns 1 on success |
1449 | * 0 on eof, when no data was read (errp is not set) | |
1450 | * negative errno on failure (errp is set) | |
1451 | */ | |
d3bd5b90 KW |
1452 | int coroutine_fn nbd_receive_reply(BlockDriverState *bs, QIOChannel *ioc, |
1453 | NBDReply *reply, Error **errp) | |
798bfe00 | 1454 | { |
ba845644 | 1455 | int ret; |
079d3266 | 1456 | const char *type; |
798bfe00 | 1457 | |
d3bd5b90 | 1458 | ret = nbd_read_eof(bs, ioc, &reply->magic, sizeof(reply->magic), errp); |
ff82911c | 1459 | if (ret <= 0) { |
798bfe00 FZ |
1460 | return ret; |
1461 | } | |
1462 | ||
80c7c2b0 | 1463 | reply->magic = be32_to_cpu(reply->magic); |
798bfe00 | 1464 | |
d2febedb VSO |
1465 | switch (reply->magic) { |
1466 | case NBD_SIMPLE_REPLY_MAGIC: | |
1467 | ret = nbd_receive_simple_reply(ioc, &reply->simple, errp); | |
1468 | if (ret < 0) { | |
1469 | break; | |
1470 | } | |
d2febedb VSO |
1471 | trace_nbd_receive_simple_reply(reply->simple.error, |
1472 | nbd_err_lookup(reply->simple.error), | |
1473 | reply->handle); | |
d2febedb VSO |
1474 | break; |
1475 | case NBD_STRUCTURED_REPLY_MAGIC: | |
1476 | ret = nbd_receive_structured_reply_chunk(ioc, &reply->structured, errp); | |
1477 | if (ret < 0) { | |
1478 | break; | |
1479 | } | |
079d3266 | 1480 | type = nbd_reply_type_lookup(reply->structured.type); |
d2febedb | 1481 | trace_nbd_receive_structured_reply_chunk(reply->structured.flags, |
079d3266 | 1482 | reply->structured.type, type, |
d2febedb VSO |
1483 | reply->structured.handle, |
1484 | reply->structured.length); | |
1485 | break; | |
1486 | default: | |
1487 | error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", reply->magic); | |
b6f5d3b5 EB |
1488 | return -EINVAL; |
1489 | } | |
d2febedb VSO |
1490 | if (ret < 0) { |
1491 | return ret; | |
798bfe00 | 1492 | } |
ba845644 VSO |
1493 | |
1494 | return 1; | |
798bfe00 FZ |
1495 | } |
1496 |