Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws> |
| 3 | * |
| 4 | * Network Block Device Client Side |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; under version 2 of the License. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, |
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | * GNU General Public License for more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License |
| 16 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
| 17 | */ |
| 18 | |
Peter Maydell | d38ea87 | 2016-01-29 17:50:05 +0000 | [diff] [blame] | 19 | #include "qemu/osdep.h" |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 20 | #include "nbd-internal.h" |
| 21 | |
| 22 | static int nbd_errno_to_system_errno(int err) |
| 23 | { |
| 24 | switch (err) { |
| 25 | case NBD_SUCCESS: |
| 26 | return 0; |
| 27 | case NBD_EPERM: |
| 28 | return EPERM; |
| 29 | case NBD_EIO: |
| 30 | return EIO; |
| 31 | case NBD_ENOMEM: |
| 32 | return ENOMEM; |
| 33 | case NBD_ENOSPC: |
| 34 | return ENOSPC; |
| 35 | case NBD_EINVAL: |
| 36 | default: |
| 37 | return EINVAL; |
| 38 | } |
| 39 | } |
| 40 | |
| 41 | /* Definitions for opaque data types */ |
| 42 | |
| 43 | static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports); |
| 44 | |
| 45 | /* That's all folks */ |
| 46 | |
| 47 | /* Basic flow for negotiation |
| 48 | |
| 49 | Server Client |
| 50 | Negotiate |
| 51 | |
| 52 | or |
| 53 | |
| 54 | Server Client |
| 55 | Negotiate #1 |
| 56 | Option |
| 57 | Negotiate #2 |
| 58 | |
| 59 | ---- |
| 60 | |
| 61 | followed by |
| 62 | |
| 63 | Server Client |
| 64 | Request |
| 65 | Response |
| 66 | Request |
| 67 | Response |
| 68 | ... |
| 69 | ... |
| 70 | Request (type == 2) |
| 71 | |
| 72 | */ |
| 73 | |
Daniel P. Berrange | 9344e5f | 2016-02-10 18:41:09 +0000 | [diff] [blame] | 74 | |
| 75 | static int nbd_handle_reply_err(uint32_t opt, uint32_t type, Error **errp) |
| 76 | { |
| 77 | if (!(type & (1 << 31))) { |
| 78 | return 0; |
| 79 | } |
| 80 | |
| 81 | switch (type) { |
| 82 | case NBD_REP_ERR_UNSUP: |
| 83 | error_setg(errp, "Unsupported option type %x", opt); |
| 84 | break; |
| 85 | |
Daniel P. Berrange | f95910f | 2016-02-10 18:41:11 +0000 | [diff] [blame] | 86 | case NBD_REP_ERR_POLICY: |
| 87 | error_setg(errp, "Denied by server for option %x", opt); |
| 88 | break; |
| 89 | |
Daniel P. Berrange | 9344e5f | 2016-02-10 18:41:09 +0000 | [diff] [blame] | 90 | case NBD_REP_ERR_INVALID: |
| 91 | error_setg(errp, "Invalid data length for option %x", opt); |
| 92 | break; |
| 93 | |
Daniel P. Berrange | f95910f | 2016-02-10 18:41:11 +0000 | [diff] [blame] | 94 | case NBD_REP_ERR_TLS_REQD: |
| 95 | error_setg(errp, "TLS negotiation required before option %x", opt); |
| 96 | break; |
| 97 | |
Daniel P. Berrange | 9344e5f | 2016-02-10 18:41:09 +0000 | [diff] [blame] | 98 | default: |
| 99 | error_setg(errp, "Unknown error code when asking for option %x", opt); |
| 100 | break; |
| 101 | } |
| 102 | |
| 103 | return -1; |
| 104 | } |
| 105 | |
| 106 | static int nbd_receive_list(QIOChannel *ioc, char **name, Error **errp) |
| 107 | { |
| 108 | uint64_t magic; |
| 109 | uint32_t opt; |
| 110 | uint32_t type; |
| 111 | uint32_t len; |
| 112 | uint32_t namelen; |
| 113 | |
| 114 | *name = NULL; |
| 115 | if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) { |
| 116 | error_setg(errp, "failed to read list option magic"); |
| 117 | return -1; |
| 118 | } |
| 119 | magic = be64_to_cpu(magic); |
| 120 | if (magic != NBD_REP_MAGIC) { |
| 121 | error_setg(errp, "Unexpected option list magic"); |
| 122 | return -1; |
| 123 | } |
| 124 | if (read_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) { |
| 125 | error_setg(errp, "failed to read list option"); |
| 126 | return -1; |
| 127 | } |
| 128 | opt = be32_to_cpu(opt); |
| 129 | if (opt != NBD_OPT_LIST) { |
| 130 | error_setg(errp, "Unexpected option type %x expected %x", |
| 131 | opt, NBD_OPT_LIST); |
| 132 | return -1; |
| 133 | } |
| 134 | |
| 135 | if (read_sync(ioc, &type, sizeof(type)) != sizeof(type)) { |
| 136 | error_setg(errp, "failed to read list option type"); |
| 137 | return -1; |
| 138 | } |
| 139 | type = be32_to_cpu(type); |
| 140 | if (type == NBD_REP_ERR_UNSUP) { |
| 141 | return 0; |
| 142 | } |
| 143 | if (nbd_handle_reply_err(opt, type, errp) < 0) { |
| 144 | return -1; |
| 145 | } |
| 146 | |
| 147 | if (read_sync(ioc, &len, sizeof(len)) != sizeof(len)) { |
| 148 | error_setg(errp, "failed to read option length"); |
| 149 | return -1; |
| 150 | } |
| 151 | len = be32_to_cpu(len); |
| 152 | |
| 153 | if (type == NBD_REP_ACK) { |
| 154 | if (len != 0) { |
| 155 | error_setg(errp, "length too long for option end"); |
| 156 | return -1; |
| 157 | } |
| 158 | } else if (type == NBD_REP_SERVER) { |
| 159 | if (read_sync(ioc, &namelen, sizeof(namelen)) != sizeof(namelen)) { |
| 160 | error_setg(errp, "failed to read option name length"); |
| 161 | return -1; |
| 162 | } |
| 163 | namelen = be32_to_cpu(namelen); |
| 164 | if (len != (namelen + sizeof(namelen))) { |
| 165 | error_setg(errp, "incorrect option mame length"); |
| 166 | return -1; |
| 167 | } |
| 168 | if (namelen > 255) { |
| 169 | error_setg(errp, "export name length too long %d", namelen); |
| 170 | return -1; |
| 171 | } |
| 172 | |
| 173 | *name = g_new0(char, namelen + 1); |
| 174 | if (read_sync(ioc, *name, namelen) != namelen) { |
| 175 | error_setg(errp, "failed to read export name"); |
| 176 | g_free(*name); |
| 177 | *name = NULL; |
| 178 | return -1; |
| 179 | } |
| 180 | (*name)[namelen] = '\0'; |
| 181 | } else { |
| 182 | error_setg(errp, "Unexpected reply type %x expected %x", |
| 183 | type, NBD_REP_SERVER); |
| 184 | return -1; |
| 185 | } |
| 186 | return 1; |
| 187 | } |
| 188 | |
| 189 | |
| 190 | static int nbd_receive_query_exports(QIOChannel *ioc, |
| 191 | const char *wantname, |
| 192 | Error **errp) |
| 193 | { |
| 194 | uint64_t magic = cpu_to_be64(NBD_OPTS_MAGIC); |
| 195 | uint32_t opt = cpu_to_be32(NBD_OPT_LIST); |
| 196 | uint32_t length = 0; |
| 197 | bool foundExport = false; |
| 198 | |
| 199 | TRACE("Querying export list"); |
| 200 | if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) { |
| 201 | error_setg(errp, "Failed to send list option magic"); |
| 202 | return -1; |
| 203 | } |
| 204 | |
| 205 | if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) { |
| 206 | error_setg(errp, "Failed to send list option number"); |
| 207 | return -1; |
| 208 | } |
| 209 | |
| 210 | if (write_sync(ioc, &length, sizeof(length)) != sizeof(length)) { |
| 211 | error_setg(errp, "Failed to send list option length"); |
| 212 | return -1; |
| 213 | } |
| 214 | |
| 215 | TRACE("Reading available export names"); |
| 216 | while (1) { |
| 217 | char *name = NULL; |
| 218 | int ret = nbd_receive_list(ioc, &name, errp); |
| 219 | |
| 220 | if (ret < 0) { |
| 221 | g_free(name); |
| 222 | name = NULL; |
| 223 | return -1; |
| 224 | } |
| 225 | if (ret == 0) { |
| 226 | /* Server doesn't support export listing, so |
| 227 | * we will just assume an export with our |
| 228 | * wanted name exists */ |
| 229 | foundExport = true; |
| 230 | break; |
| 231 | } |
| 232 | if (name == NULL) { |
| 233 | TRACE("End of export name list"); |
| 234 | break; |
| 235 | } |
| 236 | if (g_str_equal(name, wantname)) { |
| 237 | foundExport = true; |
| 238 | TRACE("Found desired export name '%s'", name); |
| 239 | } else { |
| 240 | TRACE("Ignored export name '%s'", name); |
| 241 | } |
| 242 | g_free(name); |
| 243 | } |
| 244 | |
| 245 | if (!foundExport) { |
| 246 | error_setg(errp, "No export with name '%s' available", wantname); |
| 247 | return -1; |
| 248 | } |
| 249 | |
| 250 | return 0; |
| 251 | } |
| 252 | |
Daniel P. Berrange | f95910f | 2016-02-10 18:41:11 +0000 | [diff] [blame] | 253 | static QIOChannel *nbd_receive_starttls(QIOChannel *ioc, |
| 254 | QCryptoTLSCreds *tlscreds, |
| 255 | const char *hostname, Error **errp) |
| 256 | { |
| 257 | uint64_t magic = cpu_to_be64(NBD_OPTS_MAGIC); |
| 258 | uint32_t opt = cpu_to_be32(NBD_OPT_STARTTLS); |
| 259 | uint32_t length = 0; |
| 260 | uint32_t type; |
| 261 | QIOChannelTLS *tioc; |
| 262 | struct NBDTLSHandshakeData data = { 0 }; |
| 263 | |
| 264 | TRACE("Requesting TLS from server"); |
| 265 | if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) { |
| 266 | error_setg(errp, "Failed to send option magic"); |
| 267 | return NULL; |
| 268 | } |
| 269 | |
| 270 | if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) { |
| 271 | error_setg(errp, "Failed to send option number"); |
| 272 | return NULL; |
| 273 | } |
| 274 | |
| 275 | if (write_sync(ioc, &length, sizeof(length)) != sizeof(length)) { |
| 276 | error_setg(errp, "Failed to send option length"); |
| 277 | return NULL; |
| 278 | } |
| 279 | |
| 280 | TRACE("Getting TLS reply from server1"); |
| 281 | if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) { |
| 282 | error_setg(errp, "failed to read option magic"); |
| 283 | return NULL; |
| 284 | } |
| 285 | magic = be64_to_cpu(magic); |
| 286 | if (magic != NBD_REP_MAGIC) { |
| 287 | error_setg(errp, "Unexpected option magic"); |
| 288 | return NULL; |
| 289 | } |
| 290 | TRACE("Getting TLS reply from server2"); |
| 291 | if (read_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) { |
| 292 | error_setg(errp, "failed to read option"); |
| 293 | return NULL; |
| 294 | } |
| 295 | opt = be32_to_cpu(opt); |
| 296 | if (opt != NBD_OPT_STARTTLS) { |
| 297 | error_setg(errp, "Unexpected option type %x expected %x", |
| 298 | opt, NBD_OPT_STARTTLS); |
| 299 | return NULL; |
| 300 | } |
| 301 | |
| 302 | TRACE("Getting TLS reply from server"); |
| 303 | if (read_sync(ioc, &type, sizeof(type)) != sizeof(type)) { |
| 304 | error_setg(errp, "failed to read option type"); |
| 305 | return NULL; |
| 306 | } |
| 307 | type = be32_to_cpu(type); |
| 308 | if (type != NBD_REP_ACK) { |
| 309 | error_setg(errp, "Server rejected request to start TLS %x", |
| 310 | type); |
| 311 | return NULL; |
| 312 | } |
| 313 | |
| 314 | TRACE("Getting TLS reply from server"); |
| 315 | if (read_sync(ioc, &length, sizeof(length)) != sizeof(length)) { |
| 316 | error_setg(errp, "failed to read option length"); |
| 317 | return NULL; |
| 318 | } |
| 319 | length = be32_to_cpu(length); |
| 320 | if (length != 0) { |
| 321 | error_setg(errp, "Start TLS reponse was not zero %x", |
| 322 | length); |
| 323 | return NULL; |
| 324 | } |
| 325 | |
| 326 | TRACE("TLS request approved, setting up TLS"); |
| 327 | tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp); |
| 328 | if (!tioc) { |
| 329 | return NULL; |
| 330 | } |
| 331 | data.loop = g_main_loop_new(g_main_context_default(), FALSE); |
| 332 | TRACE("Starting TLS hanshake"); |
| 333 | qio_channel_tls_handshake(tioc, |
| 334 | nbd_tls_handshake, |
| 335 | &data, |
| 336 | NULL); |
| 337 | |
| 338 | if (!data.complete) { |
| 339 | g_main_loop_run(data.loop); |
| 340 | } |
| 341 | g_main_loop_unref(data.loop); |
| 342 | if (data.error) { |
| 343 | error_propagate(errp, data.error); |
| 344 | object_unref(OBJECT(tioc)); |
| 345 | return NULL; |
| 346 | } |
| 347 | |
| 348 | return QIO_CHANNEL(tioc); |
| 349 | } |
| 350 | |
| 351 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 352 | int nbd_receive_negotiate(QIOChannel *ioc, const char *name, uint32_t *flags, |
Daniel P. Berrange | f95910f | 2016-02-10 18:41:11 +0000 | [diff] [blame] | 353 | QCryptoTLSCreds *tlscreds, const char *hostname, |
| 354 | QIOChannel **outioc, |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 355 | off_t *size, Error **errp) |
| 356 | { |
| 357 | char buf[256]; |
| 358 | uint64_t magic, s; |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 359 | int rc; |
| 360 | |
Daniel P. Berrange | f95910f | 2016-02-10 18:41:11 +0000 | [diff] [blame] | 361 | TRACE("Receiving negotiation tlscreds=%p hostname=%s.", |
| 362 | tlscreds, hostname ? hostname : "<null>"); |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 363 | |
| 364 | rc = -EINVAL; |
| 365 | |
Daniel P. Berrange | f95910f | 2016-02-10 18:41:11 +0000 | [diff] [blame] | 366 | if (outioc) { |
| 367 | *outioc = NULL; |
| 368 | } |
| 369 | if (tlscreds && !outioc) { |
| 370 | error_setg(errp, "Output I/O channel required for TLS"); |
| 371 | goto fail; |
| 372 | } |
| 373 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 374 | if (read_sync(ioc, buf, 8) != 8) { |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 375 | error_setg(errp, "Failed to read data"); |
| 376 | goto fail; |
| 377 | } |
| 378 | |
| 379 | buf[8] = '\0'; |
| 380 | if (strlen(buf) == 0) { |
| 381 | error_setg(errp, "Server connection closed unexpectedly"); |
| 382 | goto fail; |
| 383 | } |
| 384 | |
| 385 | TRACE("Magic is %c%c%c%c%c%c%c%c", |
| 386 | qemu_isprint(buf[0]) ? buf[0] : '.', |
| 387 | qemu_isprint(buf[1]) ? buf[1] : '.', |
| 388 | qemu_isprint(buf[2]) ? buf[2] : '.', |
| 389 | qemu_isprint(buf[3]) ? buf[3] : '.', |
| 390 | qemu_isprint(buf[4]) ? buf[4] : '.', |
| 391 | qemu_isprint(buf[5]) ? buf[5] : '.', |
| 392 | qemu_isprint(buf[6]) ? buf[6] : '.', |
| 393 | qemu_isprint(buf[7]) ? buf[7] : '.'); |
| 394 | |
| 395 | if (memcmp(buf, "NBDMAGIC", 8) != 0) { |
| 396 | error_setg(errp, "Invalid magic received"); |
| 397 | goto fail; |
| 398 | } |
| 399 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 400 | if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) { |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 401 | error_setg(errp, "Failed to read magic"); |
| 402 | goto fail; |
| 403 | } |
| 404 | magic = be64_to_cpu(magic); |
| 405 | TRACE("Magic is 0x%" PRIx64, magic); |
| 406 | |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 407 | if (magic == NBD_OPTS_MAGIC) { |
Daniel P. Berrange | e2a9d9a | 2016-02-10 18:41:07 +0000 | [diff] [blame] | 408 | uint32_t clientflags = 0; |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 409 | uint32_t opt; |
| 410 | uint32_t namesize; |
Daniel P. Berrange | e2a9d9a | 2016-02-10 18:41:07 +0000 | [diff] [blame] | 411 | uint16_t globalflags; |
| 412 | uint16_t exportflags; |
Daniel P. Berrange | 9344e5f | 2016-02-10 18:41:09 +0000 | [diff] [blame] | 413 | bool fixedNewStyle = false; |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 414 | |
Daniel P. Berrange | e2a9d9a | 2016-02-10 18:41:07 +0000 | [diff] [blame] | 415 | if (read_sync(ioc, &globalflags, sizeof(globalflags)) != |
| 416 | sizeof(globalflags)) { |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 417 | error_setg(errp, "Failed to read server flags"); |
| 418 | goto fail; |
| 419 | } |
Daniel P. Berrange | 9344e5f | 2016-02-10 18:41:09 +0000 | [diff] [blame] | 420 | globalflags = be16_to_cpu(globalflags); |
| 421 | *flags = globalflags << 16; |
| 422 | TRACE("Global flags are %x", globalflags); |
Daniel P. Berrange | e2a9d9a | 2016-02-10 18:41:07 +0000 | [diff] [blame] | 423 | if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) { |
Daniel P. Berrange | 9344e5f | 2016-02-10 18:41:09 +0000 | [diff] [blame] | 424 | fixedNewStyle = true; |
Daniel P. Berrange | e2a9d9a | 2016-02-10 18:41:07 +0000 | [diff] [blame] | 425 | TRACE("Server supports fixed new style"); |
| 426 | clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE; |
| 427 | } |
| 428 | /* client requested flags */ |
Daniel P. Berrange | 9344e5f | 2016-02-10 18:41:09 +0000 | [diff] [blame] | 429 | clientflags = cpu_to_be32(clientflags); |
Daniel P. Berrange | e2a9d9a | 2016-02-10 18:41:07 +0000 | [diff] [blame] | 430 | if (write_sync(ioc, &clientflags, sizeof(clientflags)) != |
| 431 | sizeof(clientflags)) { |
| 432 | error_setg(errp, "Failed to send clientflags field"); |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 433 | goto fail; |
| 434 | } |
Daniel P. Berrange | f95910f | 2016-02-10 18:41:11 +0000 | [diff] [blame] | 435 | if (tlscreds) { |
| 436 | if (fixedNewStyle) { |
| 437 | *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp); |
| 438 | if (!*outioc) { |
| 439 | goto fail; |
| 440 | } |
| 441 | ioc = *outioc; |
| 442 | } else { |
| 443 | error_setg(errp, "Server does not support STARTTLS"); |
| 444 | goto fail; |
| 445 | } |
| 446 | } |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 447 | if (!name) { |
Daniel P. Berrange | 69b4950 | 2016-02-10 18:41:10 +0000 | [diff] [blame] | 448 | TRACE("Using default NBD export name \"\""); |
| 449 | name = ""; |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 450 | } |
Daniel P. Berrange | 9344e5f | 2016-02-10 18:41:09 +0000 | [diff] [blame] | 451 | if (fixedNewStyle) { |
| 452 | /* Check our desired export is present in the |
| 453 | * server export list. Since NBD_OPT_EXPORT_NAME |
| 454 | * cannot return an error message, running this |
| 455 | * query gives us good error reporting if the |
| 456 | * server required TLS |
| 457 | */ |
| 458 | if (nbd_receive_query_exports(ioc, name, errp) < 0) { |
| 459 | goto fail; |
| 460 | } |
| 461 | } |
| 462 | /* write the export name */ |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 463 | magic = cpu_to_be64(magic); |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 464 | if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) { |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 465 | error_setg(errp, "Failed to send export name magic"); |
| 466 | goto fail; |
| 467 | } |
| 468 | opt = cpu_to_be32(NBD_OPT_EXPORT_NAME); |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 469 | if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) { |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 470 | error_setg(errp, "Failed to send export name option number"); |
| 471 | goto fail; |
| 472 | } |
| 473 | namesize = cpu_to_be32(strlen(name)); |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 474 | if (write_sync(ioc, &namesize, sizeof(namesize)) != |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 475 | sizeof(namesize)) { |
| 476 | error_setg(errp, "Failed to send export name length"); |
| 477 | goto fail; |
| 478 | } |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 479 | if (write_sync(ioc, (char *)name, strlen(name)) != strlen(name)) { |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 480 | error_setg(errp, "Failed to send export name"); |
| 481 | goto fail; |
| 482 | } |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 483 | |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 484 | if (read_sync(ioc, &s, sizeof(s)) != sizeof(s)) { |
| 485 | error_setg(errp, "Failed to read export length"); |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 486 | goto fail; |
| 487 | } |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 488 | *size = be64_to_cpu(s); |
| 489 | TRACE("Size is %" PRIu64, *size); |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 490 | |
Daniel P. Berrange | e2a9d9a | 2016-02-10 18:41:07 +0000 | [diff] [blame] | 491 | if (read_sync(ioc, &exportflags, sizeof(exportflags)) != |
| 492 | sizeof(exportflags)) { |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 493 | error_setg(errp, "Failed to read export flags"); |
| 494 | goto fail; |
| 495 | } |
Daniel P. Berrange | 9344e5f | 2016-02-10 18:41:09 +0000 | [diff] [blame] | 496 | exportflags = be16_to_cpu(exportflags); |
| 497 | *flags |= exportflags; |
| 498 | TRACE("Export flags are %x", exportflags); |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 499 | } else if (magic == NBD_CLIENT_MAGIC) { |
| 500 | if (name) { |
| 501 | error_setg(errp, "Server does not support export names"); |
| 502 | goto fail; |
| 503 | } |
Daniel P. Berrange | f95910f | 2016-02-10 18:41:11 +0000 | [diff] [blame] | 504 | if (tlscreds) { |
| 505 | error_setg(errp, "Server does not support STARTTLS"); |
| 506 | goto fail; |
| 507 | } |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 508 | |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 509 | if (read_sync(ioc, &s, sizeof(s)) != sizeof(s)) { |
| 510 | error_setg(errp, "Failed to read export length"); |
| 511 | goto fail; |
| 512 | } |
| 513 | *size = be64_to_cpu(s); |
| 514 | TRACE("Size is %" PRIu64, *size); |
| 515 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 516 | if (read_sync(ioc, flags, sizeof(*flags)) != sizeof(*flags)) { |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 517 | error_setg(errp, "Failed to read export flags"); |
| 518 | goto fail; |
| 519 | } |
| 520 | *flags = be32_to_cpup(flags); |
| 521 | } else { |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 522 | error_setg(errp, "Bad magic received"); |
| 523 | goto fail; |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 524 | } |
Daniel P. Berrange | f72d705 | 2016-02-10 18:41:05 +0000 | [diff] [blame] | 525 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 526 | if (read_sync(ioc, &buf, 124) != 124) { |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 527 | error_setg(errp, "Failed to read reserved block"); |
| 528 | goto fail; |
| 529 | } |
| 530 | rc = 0; |
| 531 | |
| 532 | fail: |
| 533 | return rc; |
| 534 | } |
| 535 | |
| 536 | #ifdef __linux__ |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 537 | int nbd_init(int fd, QIOChannelSocket *sioc, uint32_t flags, off_t size) |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 538 | { |
| 539 | TRACE("Setting NBD socket"); |
| 540 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 541 | if (ioctl(fd, NBD_SET_SOCK, sioc->fd) < 0) { |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 542 | int serrno = errno; |
| 543 | LOG("Failed to set NBD socket"); |
| 544 | return -serrno; |
| 545 | } |
| 546 | |
| 547 | TRACE("Setting block size to %lu", (unsigned long)BDRV_SECTOR_SIZE); |
| 548 | |
| 549 | if (ioctl(fd, NBD_SET_BLKSIZE, (size_t)BDRV_SECTOR_SIZE) < 0) { |
| 550 | int serrno = errno; |
| 551 | LOG("Failed setting NBD block size"); |
| 552 | return -serrno; |
| 553 | } |
| 554 | |
| 555 | TRACE("Setting size to %zd block(s)", (size_t)(size / BDRV_SECTOR_SIZE)); |
| 556 | |
| 557 | if (ioctl(fd, NBD_SET_SIZE_BLOCKS, (size_t)(size / BDRV_SECTOR_SIZE)) < 0) { |
| 558 | int serrno = errno; |
| 559 | LOG("Failed setting size (in blocks)"); |
| 560 | return -serrno; |
| 561 | } |
| 562 | |
| 563 | if (ioctl(fd, NBD_SET_FLAGS, flags) < 0) { |
| 564 | if (errno == ENOTTY) { |
| 565 | int read_only = (flags & NBD_FLAG_READ_ONLY) != 0; |
| 566 | TRACE("Setting readonly attribute"); |
| 567 | |
| 568 | if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) { |
| 569 | int serrno = errno; |
| 570 | LOG("Failed setting read-only attribute"); |
| 571 | return -serrno; |
| 572 | } |
| 573 | } else { |
| 574 | int serrno = errno; |
| 575 | LOG("Failed setting flags"); |
| 576 | return -serrno; |
| 577 | } |
| 578 | } |
| 579 | |
| 580 | TRACE("Negotiation ended"); |
| 581 | |
| 582 | return 0; |
| 583 | } |
| 584 | |
| 585 | int nbd_client(int fd) |
| 586 | { |
| 587 | int ret; |
| 588 | int serrno; |
| 589 | |
| 590 | TRACE("Doing NBD loop"); |
| 591 | |
| 592 | ret = ioctl(fd, NBD_DO_IT); |
| 593 | if (ret < 0 && errno == EPIPE) { |
| 594 | /* NBD_DO_IT normally returns EPIPE when someone has disconnected |
| 595 | * the socket via NBD_DISCONNECT. We do not want to return 1 in |
| 596 | * that case. |
| 597 | */ |
| 598 | ret = 0; |
| 599 | } |
| 600 | serrno = errno; |
| 601 | |
| 602 | TRACE("NBD loop returned %d: %s", ret, strerror(serrno)); |
| 603 | |
| 604 | TRACE("Clearing NBD queue"); |
| 605 | ioctl(fd, NBD_CLEAR_QUE); |
| 606 | |
| 607 | TRACE("Clearing NBD socket"); |
| 608 | ioctl(fd, NBD_CLEAR_SOCK); |
| 609 | |
| 610 | errno = serrno; |
| 611 | return ret; |
| 612 | } |
| 613 | #else |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 614 | int nbd_init(int fd, QIOChannelSocket *ioc, uint32_t flags, off_t size) |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 615 | { |
| 616 | return -ENOTSUP; |
| 617 | } |
| 618 | |
| 619 | int nbd_client(int fd) |
| 620 | { |
| 621 | return -ENOTSUP; |
| 622 | } |
| 623 | #endif |
| 624 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 625 | ssize_t nbd_send_request(QIOChannel *ioc, struct nbd_request *request) |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 626 | { |
| 627 | uint8_t buf[NBD_REQUEST_SIZE]; |
| 628 | ssize_t ret; |
| 629 | |
| 630 | cpu_to_be32w((uint32_t*)buf, NBD_REQUEST_MAGIC); |
| 631 | cpu_to_be32w((uint32_t*)(buf + 4), request->type); |
| 632 | cpu_to_be64w((uint64_t*)(buf + 8), request->handle); |
| 633 | cpu_to_be64w((uint64_t*)(buf + 16), request->from); |
| 634 | cpu_to_be32w((uint32_t*)(buf + 24), request->len); |
| 635 | |
| 636 | TRACE("Sending request to client: " |
| 637 | "{ .from = %" PRIu64", .len = %u, .handle = %" PRIu64", .type=%i}", |
| 638 | request->from, request->len, request->handle, request->type); |
| 639 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 640 | ret = write_sync(ioc, buf, sizeof(buf)); |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 641 | if (ret < 0) { |
| 642 | return ret; |
| 643 | } |
| 644 | |
| 645 | if (ret != sizeof(buf)) { |
| 646 | LOG("writing to socket failed"); |
| 647 | return -EINVAL; |
| 648 | } |
| 649 | return 0; |
| 650 | } |
| 651 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 652 | ssize_t nbd_receive_reply(QIOChannel *ioc, struct nbd_reply *reply) |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 653 | { |
| 654 | uint8_t buf[NBD_REPLY_SIZE]; |
| 655 | uint32_t magic; |
| 656 | ssize_t ret; |
| 657 | |
Daniel P. Berrange | 1c778ef | 2016-02-10 18:41:04 +0000 | [diff] [blame] | 658 | ret = read_sync(ioc, buf, sizeof(buf)); |
Fam Zheng | 798bfe0 | 2016-01-14 16:41:02 +0800 | [diff] [blame] | 659 | if (ret < 0) { |
| 660 | return ret; |
| 661 | } |
| 662 | |
| 663 | if (ret != sizeof(buf)) { |
| 664 | LOG("read failed"); |
| 665 | return -EINVAL; |
| 666 | } |
| 667 | |
| 668 | /* Reply |
| 669 | [ 0 .. 3] magic (NBD_REPLY_MAGIC) |
| 670 | [ 4 .. 7] error (0 == no error) |
| 671 | [ 7 .. 15] handle |
| 672 | */ |
| 673 | |
| 674 | magic = be32_to_cpup((uint32_t*)buf); |
| 675 | reply->error = be32_to_cpup((uint32_t*)(buf + 4)); |
| 676 | reply->handle = be64_to_cpup((uint64_t*)(buf + 8)); |
| 677 | |
| 678 | reply->error = nbd_errno_to_system_errno(reply->error); |
| 679 | |
| 680 | TRACE("Got reply: " |
| 681 | "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }", |
| 682 | magic, reply->error, reply->handle); |
| 683 | |
| 684 | if (magic != NBD_REPLY_MAGIC) { |
| 685 | LOG("invalid magic (got 0x%x)", magic); |
| 686 | return -EINVAL; |
| 687 | } |
| 688 | return 0; |
| 689 | } |
| 690 | |