2 * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws>
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.
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.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <sys/ioctl.h>
27 #include <sys/socket.h>
29 #include <netinet/in.h>
30 #include <netinet/tcp.h>
31 #include <arpa/inet.h>
37 static int verbose = 0;
40 #define TRACE(msg, ...) do { \
41 if (verbose) LOG(msg, ## __VA_ARGS__); \
44 #define LOG(msg, ...) do { \
45 fprintf(stderr, "%s:%s():L%d: " msg "\n", \
46 __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__); \
49 /* This is all part of the "official" NBD API */
51 #define NBD_REQUEST_MAGIC 0x25609513
52 #define NBD_REPLY_MAGIC 0x67446698
54 #define NBD_SET_SOCK _IO(0xab, 0)
55 #define NBD_SET_BLKSIZE _IO(0xab, 1)
56 #define NBD_SET_SIZE _IO(0xab, 2)
57 #define NBD_DO_IT _IO(0xab, 3)
58 #define NBD_CLEAR_SOCK _IO(0xab, 4)
59 #define NBD_CLEAR_QUE _IO(0xab, 5)
60 #define NBD_PRINT_DEBUG _IO(0xab, 6)
61 #define NBD_SET_SIZE_BLOCKS _IO(0xab, 7)
62 #define NBD_DISCONNECT _IO(0xab, 8)
64 /* That's all folks */
66 #define read_sync(fd, buffer, size) nbd_wr_sync(fd, buffer, size, true)
67 #define write_sync(fd, buffer, size) nbd_wr_sync(fd, buffer, size, false)
69 size_t nbd_wr_sync(int fd, void *buffer, size_t size, bool do_read)
73 while (offset < size) {
77 len = read(fd, buffer + offset, size - offset);
79 len = write(fd, buffer + offset, size - offset);
82 /* recoverable error */
83 if (len == -1 && (errno == EAGAIN || errno == EINTR)) {
92 /* unrecoverable error */
103 int tcp_socket_outgoing(const char *address, uint16_t port)
107 struct sockaddr_in addr;
110 s = socket(PF_INET, SOCK_STREAM, 0);
115 if (inet_aton(address, &in) == 0) {
118 ent = gethostbyname(address);
123 memcpy(&in, ent->h_addr, sizeof(in));
126 addr.sin_family = AF_INET;
127 addr.sin_port = htons(port);
128 memcpy(&addr.sin_addr.s_addr, &in, sizeof(in));
130 if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
142 int tcp_socket_incoming(const char *address, uint16_t port)
146 struct sockaddr_in addr;
150 s = socket(PF_INET, SOCK_STREAM, 0);
155 if (inet_aton(address, &in) == 0) {
158 ent = gethostbyname(address);
163 memcpy(&in, ent->h_addr, sizeof(in));
166 addr.sin_family = AF_INET;
167 addr.sin_port = htons(port);
168 memcpy(&addr.sin_addr.s_addr, &in, sizeof(in));
171 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
175 if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
179 if (listen(s, 128) == -1) {
191 int unix_socket_incoming(const char *path)
194 struct sockaddr_un addr;
197 s = socket(PF_UNIX, SOCK_STREAM, 0);
202 memset(&addr, 0, sizeof(addr));
203 addr.sun_family = AF_UNIX;
204 pstrcpy(addr.sun_path, sizeof(addr.sun_path), path);
206 if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
210 if (listen(s, 128) == -1) {
222 int unix_socket_outgoing(const char *path)
225 struct sockaddr_un addr;
228 s = socket(PF_UNIX, SOCK_STREAM, 0);
233 memset(&addr, 0, sizeof(addr));
234 addr.sun_family = AF_UNIX;
235 pstrcpy(addr.sun_path, sizeof(addr.sun_path), path);
237 if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
264 int nbd_negotiate(BlockDriverState *bs, int csock, off_t size)
266 char buf[8 + 8 + 8 + 128];
269 [ 0 .. 7] passwd ("NBDMAGIC")
270 [ 8 .. 15] magic (0x00420281861253)
272 [24 .. 151] reserved (0)
275 TRACE("Beginning negotiation.");
276 memcpy(buf, "NBDMAGIC", 8);
277 cpu_to_be64w((uint64_t*)(buf + 8), 0x00420281861253LL);
278 cpu_to_be64w((uint64_t*)(buf + 16), size);
279 memset(buf + 24, 0, 128);
281 if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
287 TRACE("Negotation succeeded.");
292 int nbd_receive_negotiate(int csock, off_t *size, size_t *blocksize)
294 char buf[8 + 8 + 8 + 128];
297 TRACE("Receiving negotation.");
299 if (read_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
305 magic = be64_to_cpup((uint64_t*)(buf + 8));
306 *size = be64_to_cpup((uint64_t*)(buf + 16));
309 TRACE("Magic is %c%c%c%c%c%c%c%c",
310 isprint(buf[0]) ? buf[0] : '.',
311 isprint(buf[1]) ? buf[1] : '.',
312 isprint(buf[2]) ? buf[2] : '.',
313 isprint(buf[3]) ? buf[3] : '.',
314 isprint(buf[4]) ? buf[4] : '.',
315 isprint(buf[5]) ? buf[5] : '.',
316 isprint(buf[6]) ? buf[6] : '.',
317 isprint(buf[7]) ? buf[7] : '.');
318 TRACE("Magic is 0x%" PRIx64, magic);
319 TRACE("Size is %" PRIu64, *size);
321 if (memcmp(buf, "NBDMAGIC", 8) != 0) {
322 LOG("Invalid magic received");
327 TRACE("Checking magic");
329 if (magic != 0x00420281861253LL) {
330 LOG("Bad magic received");
337 int nbd_init(int fd, int csock, off_t size, size_t blocksize)
339 TRACE("Setting block size to %lu", (unsigned long)blocksize);
341 if (ioctl(fd, NBD_SET_BLKSIZE, blocksize) == -1) {
343 LOG("Failed setting NBD block size");
348 TRACE("Setting size to %llu block(s)",
349 (unsigned long long)(size / blocksize));
351 if (ioctl(fd, NBD_SET_SIZE_BLOCKS, size / blocksize) == -1) {
353 LOG("Failed setting size (in blocks)");
358 TRACE("Clearing NBD socket");
360 if (ioctl(fd, NBD_CLEAR_SOCK) == -1) {
362 LOG("Failed clearing NBD socket");
367 TRACE("Setting NBD socket");
369 if (ioctl(fd, NBD_SET_SOCK, csock) == -1) {
371 LOG("Failed to set NBD socket");
376 TRACE("Negotiation ended");
381 int nbd_disconnect(int fd)
383 ioctl(fd, NBD_CLEAR_QUE);
384 ioctl(fd, NBD_DISCONNECT);
385 ioctl(fd, NBD_CLEAR_SOCK);
389 int nbd_client(int fd, int csock)
394 TRACE("Doing NBD loop");
396 ret = ioctl(fd, NBD_DO_IT);
399 TRACE("NBD loop returned %d: %s", ret, strerror(serrno));
401 TRACE("Clearing NBD queue");
402 ioctl(fd, NBD_CLEAR_QUE);
404 TRACE("Clearing NBD socket");
405 ioctl(fd, NBD_CLEAR_SOCK);
411 int nbd_send_request(int csock, struct nbd_request *request)
413 uint8_t buf[4 + 4 + 8 + 8 + 4];
415 cpu_to_be32w((uint32_t*)buf, NBD_REQUEST_MAGIC);
416 cpu_to_be32w((uint32_t*)(buf + 4), request->type);
417 cpu_to_be64w((uint64_t*)(buf + 8), request->handle);
418 cpu_to_be64w((uint64_t*)(buf + 16), request->from);
419 cpu_to_be32w((uint32_t*)(buf + 24), request->len);
421 TRACE("Sending request to client");
423 if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
424 LOG("writing to socket failed");
432 static int nbd_receive_request(int csock, struct nbd_request *request)
434 uint8_t buf[4 + 4 + 8 + 8 + 4];
437 if (read_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
444 [ 0 .. 3] magic (NBD_REQUEST_MAGIC)
445 [ 4 .. 7] type (0 == READ, 1 == WRITE)
451 magic = be32_to_cpup((uint32_t*)buf);
452 request->type = be32_to_cpup((uint32_t*)(buf + 4));
453 request->handle = be64_to_cpup((uint64_t*)(buf + 8));
454 request->from = be64_to_cpup((uint64_t*)(buf + 16));
455 request->len = be32_to_cpup((uint32_t*)(buf + 24));
457 TRACE("Got request: "
458 "{ magic = 0x%x, .type = %d, from = %" PRIu64" , len = %u }",
459 magic, request->type, request->from, request->len);
461 if (magic != NBD_REQUEST_MAGIC) {
462 LOG("invalid magic (got 0x%x)", magic);
468 int nbd_receive_reply(int csock, struct nbd_reply *reply)
470 uint8_t buf[4 + 4 + 8];
473 memset(buf, 0xAA, sizeof(buf));
475 if (read_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
482 [ 0 .. 3] magic (NBD_REPLY_MAGIC)
483 [ 4 .. 7] error (0 == no error)
487 magic = be32_to_cpup((uint32_t*)buf);
488 reply->error = be32_to_cpup((uint32_t*)(buf + 4));
489 reply->handle = be64_to_cpup((uint64_t*)(buf + 8));
492 "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }",
493 magic, reply->error, reply->handle);
495 if (magic != NBD_REPLY_MAGIC) {
496 LOG("invalid magic (got 0x%x)", magic);
503 static int nbd_send_reply(int csock, struct nbd_reply *reply)
505 uint8_t buf[4 + 4 + 8];
508 [ 0 .. 3] magic (NBD_REPLY_MAGIC)
509 [ 4 .. 7] error (0 == no error)
512 cpu_to_be32w((uint32_t*)buf, NBD_REPLY_MAGIC);
513 cpu_to_be32w((uint32_t*)(buf + 4), reply->error);
514 cpu_to_be64w((uint64_t*)(buf + 8), reply->handle);
516 TRACE("Sending response to client");
518 if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
519 LOG("writing to socket failed");
526 int nbd_trip(BlockDriverState *bs, int csock, off_t size, uint64_t dev_offset,
527 off_t *offset, bool readonly, uint8_t *data, int data_size)
529 struct nbd_request request;
530 struct nbd_reply reply;
532 TRACE("Reading request.");
534 if (nbd_receive_request(csock, &request) == -1)
537 if (request.len > data_size) {
538 LOG("len (%u) is larger than max len (%u)",
539 request.len, data_size);
544 if ((request.from + request.len) < request.from) {
545 LOG("integer overflow detected! "
546 "you're probably being attacked");
551 if ((request.from + request.len) > size) {
552 LOG("From: %" PRIu64 ", Len: %u, Size: %" PRIu64
553 ", Offset: %" PRIu64 "\n",
554 request.from, request.len, size, dev_offset);
555 LOG("requested operation past EOF--bad client?");
560 TRACE("Decoding type");
562 reply.handle = request.handle;
565 switch (request.type) {
567 TRACE("Request type is READ");
569 if (bdrv_read(bs, (request.from + dev_offset) / 512, data,
570 request.len / 512) == -1) {
571 LOG("reading from file failed");
575 *offset += request.len;
577 TRACE("Read %u byte(s)", request.len);
579 if (nbd_send_reply(csock, &reply) == -1)
582 TRACE("Sending data to client");
584 if (write_sync(csock, data, request.len) != request.len) {
585 LOG("writing to socket failed");
591 TRACE("Request type is WRITE");
593 TRACE("Reading %u byte(s)", request.len);
595 if (read_sync(csock, data, request.len) != request.len) {
596 LOG("reading from socket failed");
602 TRACE("Server is read-only, return error");
605 TRACE("Writing to device");
607 if (bdrv_write(bs, (request.from + dev_offset) / 512,
608 data, request.len / 512) == -1) {
609 LOG("writing to file failed");
614 *offset += request.len;
617 if (nbd_send_reply(csock, &reply) == -1)
621 TRACE("Request type is DISCONNECT");
625 LOG("invalid request type (%u) received", request.type);
630 TRACE("Request/Reply complete");