blob: 0dcd86b52fba3d963a67ef873243c8b3c78d21d0 [file] [log] [blame]
ths75818252008-07-03 13:41:03 +00001/*
bellard7a5ca862008-05-27 21:13:40 +00002 * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws>
3 *
4 * Network Block Device
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
Blue Swirl8167ee82009-07-16 20:47:01 +000016 * along with this program; if not, see <http://www.gnu.org/licenses/>.
ths75818252008-07-03 13:41:03 +000017 */
bellard7a5ca862008-05-27 21:13:40 +000018
19#include "nbd.h"
20
21#include <errno.h>
22#include <string.h>
aliguori03ff3ca2008-09-15 15:51:35 +000023#ifndef _WIN32
bellard7a5ca862008-05-27 21:13:40 +000024#include <sys/ioctl.h>
aliguori03ff3ca2008-09-15 15:51:35 +000025#endif
Andreas Färber5dc2eec2010-09-20 00:50:46 +020026#if defined(__sun__) || defined(__HAIKU__)
aliguori7e00eb92008-08-02 01:57:02 +000027#include <sys/ioccom.h>
28#endif
bellard7a5ca862008-05-27 21:13:40 +000029#include <ctype.h>
30#include <inttypes.h>
bellard7a5ca862008-05-27 21:13:40 +000031
aliguori03ff3ca2008-09-15 15:51:35 +000032#include "qemu_socket.h"
ths75818252008-07-03 13:41:03 +000033
aliguori03ff3ca2008-09-15 15:51:35 +000034//#define DEBUG_NBD
35
36#ifdef DEBUG_NBD
ths75818252008-07-03 13:41:03 +000037#define TRACE(msg, ...) do { \
aliguori03ff3ca2008-09-15 15:51:35 +000038 LOG(msg, ## __VA_ARGS__); \
ths75818252008-07-03 13:41:03 +000039} while(0)
aliguori03ff3ca2008-09-15 15:51:35 +000040#else
41#define TRACE(msg, ...) \
42 do { } while (0)
43#endif
bellard7a5ca862008-05-27 21:13:40 +000044
45#define LOG(msg, ...) do { \
46 fprintf(stderr, "%s:%s():L%d: " msg "\n", \
47 __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__); \
48} while(0)
49
bellard7a5ca862008-05-27 21:13:40 +000050/* This is all part of the "official" NBD API */
51
Nick Thomasb2e3d872011-02-22 15:44:51 +000052#define NBD_REPLY_SIZE (4 + 4 + 8)
bellard7a5ca862008-05-27 21:13:40 +000053#define NBD_REQUEST_MAGIC 0x25609513
54#define NBD_REPLY_MAGIC 0x67446698
55
56#define NBD_SET_SOCK _IO(0xab, 0)
57#define NBD_SET_BLKSIZE _IO(0xab, 1)
58#define NBD_SET_SIZE _IO(0xab, 2)
59#define NBD_DO_IT _IO(0xab, 3)
60#define NBD_CLEAR_SOCK _IO(0xab, 4)
61#define NBD_CLEAR_QUE _IO(0xab, 5)
Nick Thomasb2e3d872011-02-22 15:44:51 +000062#define NBD_PRINT_DEBUG _IO(0xab, 6)
63#define NBD_SET_SIZE_BLOCKS _IO(0xab, 7)
bellard7a5ca862008-05-27 21:13:40 +000064#define NBD_DISCONNECT _IO(0xab, 8)
65
Nick Thomasb2e3d872011-02-22 15:44:51 +000066#define NBD_OPT_EXPORT_NAME (1 << 0)
Laurent Vivier1d45f8b2010-08-25 22:48:33 +020067
bellard7a5ca862008-05-27 21:13:40 +000068/* That's all folks */
69
ths75818252008-07-03 13:41:03 +000070#define read_sync(fd, buffer, size) nbd_wr_sync(fd, buffer, size, true)
71#define write_sync(fd, buffer, size) nbd_wr_sync(fd, buffer, size, false)
bellard7a5ca862008-05-27 21:13:40 +000072
ths75818252008-07-03 13:41:03 +000073size_t nbd_wr_sync(int fd, void *buffer, size_t size, bool do_read)
bellard7a5ca862008-05-27 21:13:40 +000074{
75 size_t offset = 0;
76
77 while (offset < size) {
78 ssize_t len;
79
80 if (do_read) {
aliguori03ff3ca2008-09-15 15:51:35 +000081 len = recv(fd, buffer + offset, size - offset, 0);
bellard7a5ca862008-05-27 21:13:40 +000082 } else {
aliguori03ff3ca2008-09-15 15:51:35 +000083 len = send(fd, buffer + offset, size - offset, 0);
bellard7a5ca862008-05-27 21:13:40 +000084 }
85
aliguori03ff3ca2008-09-15 15:51:35 +000086 if (len == -1)
87 errno = socket_error();
88
bellard7a5ca862008-05-27 21:13:40 +000089 /* recoverable error */
ths75818252008-07-03 13:41:03 +000090 if (len == -1 && (errno == EAGAIN || errno == EINTR)) {
bellard7a5ca862008-05-27 21:13:40 +000091 continue;
92 }
93
94 /* eof */
95 if (len == 0) {
96 break;
97 }
98
99 /* unrecoverable error */
100 if (len == -1) {
101 return 0;
102 }
103
104 offset += len;
105 }
106
107 return offset;
108}
109
Nick Thomasc12504c2011-02-22 15:44:53 +0000110static void combine_addr(char *buf, size_t len, const char* address,
111 uint16_t port)
112{
113 /* If the address-part contains a colon, it's an IPv6 IP so needs [] */
114 if (strstr(address, ":")) {
115 snprintf(buf, len, "[%s]:%u", address, port);
116 } else {
117 snprintf(buf, len, "%s:%u", address, port);
118 }
119}
120
ths75818252008-07-03 13:41:03 +0000121int tcp_socket_outgoing(const char *address, uint16_t port)
bellard7a5ca862008-05-27 21:13:40 +0000122{
Nick Thomasc12504c2011-02-22 15:44:53 +0000123 char address_and_port[128];
124 combine_addr(address_and_port, 128, address, port);
125 return tcp_socket_outgoing_spec(address_and_port);
126}
bellard7a5ca862008-05-27 21:13:40 +0000127
Nick Thomasc12504c2011-02-22 15:44:53 +0000128int tcp_socket_outgoing_spec(const char *address_and_port)
129{
130 return inet_connect(address_and_port, SOCK_STREAM);
bellard7a5ca862008-05-27 21:13:40 +0000131}
132
133int tcp_socket_incoming(const char *address, uint16_t port)
134{
Nick Thomasc12504c2011-02-22 15:44:53 +0000135 char address_and_port[128];
136 combine_addr(address_and_port, 128, address, port);
137 return tcp_socket_incoming_spec(address_and_port);
bellard7a5ca862008-05-27 21:13:40 +0000138}
139
Nick Thomasc12504c2011-02-22 15:44:53 +0000140int tcp_socket_incoming_spec(const char *address_and_port)
141{
142 char *ostr = NULL;
143 int olen = 0;
144 return inet_listen(address_and_port, ostr, olen, SOCK_STREAM, 0);
145}
146
thscd831bd2008-07-03 10:23:51 +0000147int unix_socket_incoming(const char *path)
148{
Nick Thomasc12504c2011-02-22 15:44:53 +0000149 char *ostr = NULL;
150 int olen = 0;
thscd831bd2008-07-03 10:23:51 +0000151
Nick Thomasc12504c2011-02-22 15:44:53 +0000152 return unix_listen(path, ostr, olen);
thscd831bd2008-07-03 10:23:51 +0000153}
154
155int unix_socket_outgoing(const char *path)
156{
Nick Thomasc12504c2011-02-22 15:44:53 +0000157 return unix_connect(path);
thscd831bd2008-07-03 10:23:51 +0000158}
thscd831bd2008-07-03 10:23:51 +0000159
bellard7a5ca862008-05-27 21:13:40 +0000160/* Basic flow
161
162 Server Client
163
164 Negotiate
165 Request
166 Response
167 Request
168 Response
169 ...
170 ...
171 Request (type == 2)
172*/
173
aliguori27982662008-09-10 15:23:19 +0000174int nbd_negotiate(int csock, off_t size)
bellard7a5ca862008-05-27 21:13:40 +0000175{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000176 char buf[8 + 8 + 8 + 128];
bellard7a5ca862008-05-27 21:13:40 +0000177
Nick Thomasb2e3d872011-02-22 15:44:51 +0000178 /* Negotiate
179 [ 0 .. 7] passwd ("NBDMAGIC")
180 [ 8 .. 15] magic (0x00420281861253)
181 [16 .. 23] size
182 [24 .. 151] reserved (0)
183 */
bellard7a5ca862008-05-27 21:13:40 +0000184
Nick Thomasb2e3d872011-02-22 15:44:51 +0000185 TRACE("Beginning negotiation.");
186 memcpy(buf, "NBDMAGIC", 8);
187 cpu_to_be64w((uint64_t*)(buf + 8), 0x00420281861253LL);
188 cpu_to_be64w((uint64_t*)(buf + 16), size);
189 memset(buf + 24, 0, 128);
bellard7a5ca862008-05-27 21:13:40 +0000190
Nick Thomasb2e3d872011-02-22 15:44:51 +0000191 if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
192 LOG("write failed");
193 errno = EINVAL;
194 return -1;
195 }
bellard7a5ca862008-05-27 21:13:40 +0000196
Nick Thomasb2e3d872011-02-22 15:44:51 +0000197 TRACE("Negotation succeeded.");
bellard7a5ca862008-05-27 21:13:40 +0000198
Nick Thomasb2e3d872011-02-22 15:44:51 +0000199 return 0;
bellard7a5ca862008-05-27 21:13:40 +0000200}
201
Laurent Vivier1d45f8b2010-08-25 22:48:33 +0200202int nbd_receive_negotiate(int csock, const char *name, uint32_t *flags,
203 off_t *size, size_t *blocksize)
bellard7a5ca862008-05-27 21:13:40 +0000204{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000205 char buf[256];
206 uint64_t magic, s;
207 uint16_t tmp;
bellard7a5ca862008-05-27 21:13:40 +0000208
Nick Thomasb2e3d872011-02-22 15:44:51 +0000209 TRACE("Receiving negotation.");
bellard7a5ca862008-05-27 21:13:40 +0000210
Nick Thomasb2e3d872011-02-22 15:44:51 +0000211 if (read_sync(csock, buf, 8) != 8) {
212 LOG("read failed");
213 errno = EINVAL;
214 return -1;
215 }
bellard7a5ca862008-05-27 21:13:40 +0000216
Nick Thomasb2e3d872011-02-22 15:44:51 +0000217 buf[8] = '\0';
218 if (strlen(buf) == 0) {
219 LOG("server connection closed");
220 errno = EINVAL;
221 return -1;
222 }
bellard7a5ca862008-05-27 21:13:40 +0000223
Nick Thomasb2e3d872011-02-22 15:44:51 +0000224 TRACE("Magic is %c%c%c%c%c%c%c%c",
225 qemu_isprint(buf[0]) ? buf[0] : '.',
226 qemu_isprint(buf[1]) ? buf[1] : '.',
227 qemu_isprint(buf[2]) ? buf[2] : '.',
228 qemu_isprint(buf[3]) ? buf[3] : '.',
229 qemu_isprint(buf[4]) ? buf[4] : '.',
230 qemu_isprint(buf[5]) ? buf[5] : '.',
231 qemu_isprint(buf[6]) ? buf[6] : '.',
232 qemu_isprint(buf[7]) ? buf[7] : '.');
bellard7a5ca862008-05-27 21:13:40 +0000233
Nick Thomasb2e3d872011-02-22 15:44:51 +0000234 if (memcmp(buf, "NBDMAGIC", 8) != 0) {
235 LOG("Invalid magic received");
236 errno = EINVAL;
237 return -1;
238 }
bellard7a5ca862008-05-27 21:13:40 +0000239
Nick Thomasb2e3d872011-02-22 15:44:51 +0000240 if (read_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
241 LOG("read failed");
242 errno = EINVAL;
243 return -1;
244 }
245 magic = be64_to_cpu(magic);
246 TRACE("Magic is 0x%" PRIx64, magic);
bellard7a5ca862008-05-27 21:13:40 +0000247
Nick Thomasb2e3d872011-02-22 15:44:51 +0000248 if (name) {
249 uint32_t reserved = 0;
250 uint32_t opt;
251 uint32_t namesize;
Laurent Vivier1d45f8b2010-08-25 22:48:33 +0200252
Nick Thomasb2e3d872011-02-22 15:44:51 +0000253 TRACE("Checking magic (opts_magic)");
254 if (magic != 0x49484156454F5054LL) {
255 LOG("Bad magic received");
256 errno = EINVAL;
257 return -1;
258 }
259 if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) {
260 LOG("flags read failed");
261 errno = EINVAL;
262 return -1;
263 }
264 *flags = be16_to_cpu(tmp) << 16;
265 /* reserved for future use */
266 if (write_sync(csock, &reserved, sizeof(reserved)) !=
267 sizeof(reserved)) {
268 LOG("write failed (reserved)");
269 errno = EINVAL;
270 return -1;
271 }
272 /* write the export name */
273 magic = cpu_to_be64(magic);
274 if (write_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
275 LOG("write failed (magic)");
276 errno = EINVAL;
277 return -1;
278 }
279 opt = cpu_to_be32(NBD_OPT_EXPORT_NAME);
280 if (write_sync(csock, &opt, sizeof(opt)) != sizeof(opt)) {
281 LOG("write failed (opt)");
282 errno = EINVAL;
283 return -1;
284 }
285 namesize = cpu_to_be32(strlen(name));
286 if (write_sync(csock, &namesize, sizeof(namesize)) !=
287 sizeof(namesize)) {
288 LOG("write failed (namesize)");
289 errno = EINVAL;
290 return -1;
291 }
292 if (write_sync(csock, (char*)name, strlen(name)) != strlen(name)) {
293 LOG("write failed (name)");
294 errno = EINVAL;
295 return -1;
296 }
297 } else {
298 TRACE("Checking magic (cli_magic)");
Laurent Vivier1d45f8b2010-08-25 22:48:33 +0200299
Nick Thomasb2e3d872011-02-22 15:44:51 +0000300 if (magic != 0x00420281861253LL) {
301 LOG("Bad magic received");
302 errno = EINVAL;
303 return -1;
304 }
305 }
Laurent Vivier1d45f8b2010-08-25 22:48:33 +0200306
Nick Thomasb2e3d872011-02-22 15:44:51 +0000307 if (read_sync(csock, &s, sizeof(s)) != sizeof(s)) {
308 LOG("read failed");
309 errno = EINVAL;
310 return -1;
311 }
312 *size = be64_to_cpu(s);
313 *blocksize = 1024;
314 TRACE("Size is %" PRIu64, *size);
Laurent Vivier1d45f8b2010-08-25 22:48:33 +0200315
Nick Thomasb2e3d872011-02-22 15:44:51 +0000316 if (!name) {
317 if (read_sync(csock, flags, sizeof(*flags)) != sizeof(*flags)) {
318 LOG("read failed (flags)");
319 errno = EINVAL;
320 return -1;
321 }
322 *flags = be32_to_cpup(flags);
323 } else {
324 if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) {
325 LOG("read failed (tmp)");
326 errno = EINVAL;
327 return -1;
328 }
329 *flags |= be32_to_cpu(tmp);
330 }
331 if (read_sync(csock, &buf, 124) != 124) {
332 LOG("read failed (buf)");
333 errno = EINVAL;
334 return -1;
335 }
thscd831bd2008-07-03 10:23:51 +0000336 return 0;
337}
bellard7a5ca862008-05-27 21:13:40 +0000338
aliguori03ff3ca2008-09-15 15:51:35 +0000339#ifndef _WIN32
thscd831bd2008-07-03 10:23:51 +0000340int nbd_init(int fd, int csock, off_t size, size_t blocksize)
341{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000342 TRACE("Setting block size to %lu", (unsigned long)blocksize);
bellard7a5ca862008-05-27 21:13:40 +0000343
Nick Thomasb2e3d872011-02-22 15:44:51 +0000344 if (ioctl(fd, NBD_SET_BLKSIZE, blocksize) == -1) {
345 int serrno = errno;
346 LOG("Failed setting NBD block size");
347 errno = serrno;
348 return -1;
349 }
bellard7a5ca862008-05-27 21:13:40 +0000350
Blue Swirl0bfcd592010-05-22 08:02:12 +0000351 TRACE("Setting size to %zd block(s)", (size_t)(size / blocksize));
bellard7a5ca862008-05-27 21:13:40 +0000352
Nick Thomasb2e3d872011-02-22 15:44:51 +0000353 if (ioctl(fd, NBD_SET_SIZE_BLOCKS, size / blocksize) == -1) {
354 int serrno = errno;
355 LOG("Failed setting size (in blocks)");
356 errno = serrno;
357 return -1;
358 }
bellard7a5ca862008-05-27 21:13:40 +0000359
Nick Thomasb2e3d872011-02-22 15:44:51 +0000360 TRACE("Clearing NBD socket");
bellard7a5ca862008-05-27 21:13:40 +0000361
Nick Thomasb2e3d872011-02-22 15:44:51 +0000362 if (ioctl(fd, NBD_CLEAR_SOCK) == -1) {
363 int serrno = errno;
364 LOG("Failed clearing NBD socket");
365 errno = serrno;
366 return -1;
367 }
bellard7a5ca862008-05-27 21:13:40 +0000368
Nick Thomasb2e3d872011-02-22 15:44:51 +0000369 TRACE("Setting NBD socket");
bellard7a5ca862008-05-27 21:13:40 +0000370
Nick Thomasb2e3d872011-02-22 15:44:51 +0000371 if (ioctl(fd, NBD_SET_SOCK, csock) == -1) {
372 int serrno = errno;
373 LOG("Failed to set NBD socket");
374 errno = serrno;
375 return -1;
376 }
bellard7a5ca862008-05-27 21:13:40 +0000377
Nick Thomasb2e3d872011-02-22 15:44:51 +0000378 TRACE("Negotiation ended");
bellard7a5ca862008-05-27 21:13:40 +0000379
Nick Thomasb2e3d872011-02-22 15:44:51 +0000380 return 0;
bellard7a5ca862008-05-27 21:13:40 +0000381}
382
383int nbd_disconnect(int fd)
384{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000385 ioctl(fd, NBD_CLEAR_QUE);
386 ioctl(fd, NBD_DISCONNECT);
387 ioctl(fd, NBD_CLEAR_SOCK);
388 return 0;
bellard7a5ca862008-05-27 21:13:40 +0000389}
390
Jes Sorensen0a4eb862010-08-31 09:30:33 +0200391int nbd_client(int fd)
bellard7a5ca862008-05-27 21:13:40 +0000392{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000393 int ret;
394 int serrno;
bellard7a5ca862008-05-27 21:13:40 +0000395
Nick Thomasb2e3d872011-02-22 15:44:51 +0000396 TRACE("Doing NBD loop");
bellard7a5ca862008-05-27 21:13:40 +0000397
Nick Thomasb2e3d872011-02-22 15:44:51 +0000398 ret = ioctl(fd, NBD_DO_IT);
399 serrno = errno;
bellard7a5ca862008-05-27 21:13:40 +0000400
Nick Thomasb2e3d872011-02-22 15:44:51 +0000401 TRACE("NBD loop returned %d: %s", ret, strerror(serrno));
bellard7a5ca862008-05-27 21:13:40 +0000402
Nick Thomasb2e3d872011-02-22 15:44:51 +0000403 TRACE("Clearing NBD queue");
404 ioctl(fd, NBD_CLEAR_QUE);
bellard7a5ca862008-05-27 21:13:40 +0000405
Nick Thomasb2e3d872011-02-22 15:44:51 +0000406 TRACE("Clearing NBD socket");
407 ioctl(fd, NBD_CLEAR_SOCK);
bellard7a5ca862008-05-27 21:13:40 +0000408
Nick Thomasb2e3d872011-02-22 15:44:51 +0000409 errno = serrno;
410 return ret;
bellard7a5ca862008-05-27 21:13:40 +0000411}
aliguori03ff3ca2008-09-15 15:51:35 +0000412#else
413int nbd_init(int fd, int csock, off_t size, size_t blocksize)
414{
415 errno = ENOTSUP;
416 return -1;
417}
418
419int nbd_disconnect(int fd)
420{
421 errno = ENOTSUP;
422 return -1;
423}
424
Jes Sorensen0a4eb862010-08-31 09:30:33 +0200425int nbd_client(int fd)
aliguori03ff3ca2008-09-15 15:51:35 +0000426{
427 errno = ENOTSUP;
428 return -1;
429}
430#endif
bellard7a5ca862008-05-27 21:13:40 +0000431
ths75818252008-07-03 13:41:03 +0000432int nbd_send_request(int csock, struct nbd_request *request)
433{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000434 uint8_t buf[4 + 4 + 8 + 8 + 4];
ths75818252008-07-03 13:41:03 +0000435
Nick Thomasb2e3d872011-02-22 15:44:51 +0000436 cpu_to_be32w((uint32_t*)buf, NBD_REQUEST_MAGIC);
437 cpu_to_be32w((uint32_t*)(buf + 4), request->type);
438 cpu_to_be64w((uint64_t*)(buf + 8), request->handle);
439 cpu_to_be64w((uint64_t*)(buf + 16), request->from);
440 cpu_to_be32w((uint32_t*)(buf + 24), request->len);
ths75818252008-07-03 13:41:03 +0000441
Nick Thomasb2e3d872011-02-22 15:44:51 +0000442 TRACE("Sending request to client: "
443 "{ .from = %" PRIu64", .len = %u, .handle = %" PRIu64", .type=%i}",
444 request->from, request->len, request->handle, request->type);
ths75818252008-07-03 13:41:03 +0000445
Nick Thomasb2e3d872011-02-22 15:44:51 +0000446 if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
447 LOG("writing to socket failed");
448 errno = EINVAL;
449 return -1;
450 }
451 return 0;
ths75818252008-07-03 13:41:03 +0000452}
453
ths75818252008-07-03 13:41:03 +0000454static int nbd_receive_request(int csock, struct nbd_request *request)
bellard7a5ca862008-05-27 21:13:40 +0000455{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000456 uint8_t buf[4 + 4 + 8 + 8 + 4];
457 uint32_t magic;
bellard7a5ca862008-05-27 21:13:40 +0000458
Nick Thomasb2e3d872011-02-22 15:44:51 +0000459 if (read_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
460 LOG("read failed");
461 errno = EINVAL;
462 return -1;
463 }
bellard7a5ca862008-05-27 21:13:40 +0000464
Nick Thomasb2e3d872011-02-22 15:44:51 +0000465 /* Request
466 [ 0 .. 3] magic (NBD_REQUEST_MAGIC)
467 [ 4 .. 7] type (0 == READ, 1 == WRITE)
468 [ 8 .. 15] handle
469 [16 .. 23] from
470 [24 .. 27] len
471 */
bellard7a5ca862008-05-27 21:13:40 +0000472
Nick Thomasb2e3d872011-02-22 15:44:51 +0000473 magic = be32_to_cpup((uint32_t*)buf);
474 request->type = be32_to_cpup((uint32_t*)(buf + 4));
475 request->handle = be64_to_cpup((uint64_t*)(buf + 8));
476 request->from = be64_to_cpup((uint64_t*)(buf + 16));
477 request->len = be32_to_cpup((uint32_t*)(buf + 24));
bellard7a5ca862008-05-27 21:13:40 +0000478
Nick Thomasb2e3d872011-02-22 15:44:51 +0000479 TRACE("Got request: "
480 "{ magic = 0x%x, .type = %d, from = %" PRIu64" , len = %u }",
481 magic, request->type, request->from, request->len);
bellard7a5ca862008-05-27 21:13:40 +0000482
Nick Thomasb2e3d872011-02-22 15:44:51 +0000483 if (magic != NBD_REQUEST_MAGIC) {
484 LOG("invalid magic (got 0x%x)", magic);
485 errno = EINVAL;
486 return -1;
487 }
488 return 0;
ths75818252008-07-03 13:41:03 +0000489}
bellard7a5ca862008-05-27 21:13:40 +0000490
ths75818252008-07-03 13:41:03 +0000491int nbd_receive_reply(int csock, struct nbd_reply *reply)
492{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000493 uint8_t buf[NBD_REPLY_SIZE];
494 uint32_t magic;
ths75818252008-07-03 13:41:03 +0000495
Nick Thomasb2e3d872011-02-22 15:44:51 +0000496 memset(buf, 0xAA, sizeof(buf));
ths75818252008-07-03 13:41:03 +0000497
Nick Thomasb2e3d872011-02-22 15:44:51 +0000498 if (read_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
499 LOG("read failed");
500 errno = EINVAL;
501 return -1;
502 }
bellard7a5ca862008-05-27 21:13:40 +0000503
Nick Thomasb2e3d872011-02-22 15:44:51 +0000504 /* Reply
505 [ 0 .. 3] magic (NBD_REPLY_MAGIC)
506 [ 4 .. 7] error (0 == no error)
507 [ 7 .. 15] handle
508 */
ths75818252008-07-03 13:41:03 +0000509
Nick Thomasb2e3d872011-02-22 15:44:51 +0000510 magic = be32_to_cpup((uint32_t*)buf);
511 reply->error = be32_to_cpup((uint32_t*)(buf + 4));
512 reply->handle = be64_to_cpup((uint64_t*)(buf + 8));
ths75818252008-07-03 13:41:03 +0000513
Nick Thomasb2e3d872011-02-22 15:44:51 +0000514 TRACE("Got reply: "
515 "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }",
516 magic, reply->error, reply->handle);
ths75818252008-07-03 13:41:03 +0000517
Nick Thomasb2e3d872011-02-22 15:44:51 +0000518 if (magic != NBD_REPLY_MAGIC) {
519 LOG("invalid magic (got 0x%x)", magic);
520 errno = EINVAL;
521 return -1;
522 }
523 return 0;
ths75818252008-07-03 13:41:03 +0000524}
525
526static int nbd_send_reply(int csock, struct nbd_reply *reply)
527{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000528 uint8_t buf[4 + 4 + 8];
ths75818252008-07-03 13:41:03 +0000529
Nick Thomasb2e3d872011-02-22 15:44:51 +0000530 /* Reply
531 [ 0 .. 3] magic (NBD_REPLY_MAGIC)
532 [ 4 .. 7] error (0 == no error)
533 [ 7 .. 15] handle
534 */
535 cpu_to_be32w((uint32_t*)buf, NBD_REPLY_MAGIC);
536 cpu_to_be32w((uint32_t*)(buf + 4), reply->error);
537 cpu_to_be64w((uint64_t*)(buf + 8), reply->handle);
ths75818252008-07-03 13:41:03 +0000538
Nick Thomasb2e3d872011-02-22 15:44:51 +0000539 TRACE("Sending response to client");
ths75818252008-07-03 13:41:03 +0000540
Nick Thomasb2e3d872011-02-22 15:44:51 +0000541 if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
542 LOG("writing to socket failed");
543 errno = EINVAL;
544 return -1;
545 }
546 return 0;
ths75818252008-07-03 13:41:03 +0000547}
548
549int nbd_trip(BlockDriverState *bs, int csock, off_t size, uint64_t dev_offset,
550 off_t *offset, bool readonly, uint8_t *data, int data_size)
551{
Nick Thomasb2e3d872011-02-22 15:44:51 +0000552 struct nbd_request request;
553 struct nbd_reply reply;
ths75818252008-07-03 13:41:03 +0000554
Nick Thomasb2e3d872011-02-22 15:44:51 +0000555 TRACE("Reading request.");
ths75818252008-07-03 13:41:03 +0000556
Nick Thomasb2e3d872011-02-22 15:44:51 +0000557 if (nbd_receive_request(csock, &request) == -1)
558 return -1;
ths75818252008-07-03 13:41:03 +0000559
Nick Thomasb2e3d872011-02-22 15:44:51 +0000560 if (request.len + NBD_REPLY_SIZE > data_size) {
561 LOG("len (%u) is larger than max len (%u)",
562 request.len + NBD_REPLY_SIZE, data_size);
563 errno = EINVAL;
564 return -1;
565 }
ths75818252008-07-03 13:41:03 +0000566
Nick Thomasb2e3d872011-02-22 15:44:51 +0000567 if ((request.from + request.len) < request.from) {
568 LOG("integer overflow detected! "
569 "you're probably being attacked");
570 errno = EINVAL;
571 return -1;
572 }
bellard7a5ca862008-05-27 21:13:40 +0000573
Nick Thomasb2e3d872011-02-22 15:44:51 +0000574 if ((request.from + request.len) > size) {
575 LOG("From: %" PRIu64 ", Len: %u, Size: %" PRIu64
576 ", Offset: %" PRIu64 "\n",
blueswir1b9e82a52009-04-05 18:03:31 +0000577 request.from, request.len, (uint64_t)size, dev_offset);
Nick Thomasb2e3d872011-02-22 15:44:51 +0000578 LOG("requested operation past EOF--bad client?");
579 errno = EINVAL;
580 return -1;
581 }
bellard7a5ca862008-05-27 21:13:40 +0000582
Nick Thomasb2e3d872011-02-22 15:44:51 +0000583 TRACE("Decoding type");
bellard7a5ca862008-05-27 21:13:40 +0000584
Nick Thomasb2e3d872011-02-22 15:44:51 +0000585 reply.handle = request.handle;
586 reply.error = 0;
ths75818252008-07-03 13:41:03 +0000587
Nick Thomasb2e3d872011-02-22 15:44:51 +0000588 switch (request.type) {
589 case NBD_CMD_READ:
590 TRACE("Request type is READ");
bellard7a5ca862008-05-27 21:13:40 +0000591
Nick Thomasb2e3d872011-02-22 15:44:51 +0000592 if (bdrv_read(bs, (request.from + dev_offset) / 512,
593 data + NBD_REPLY_SIZE,
594 request.len / 512) == -1) {
595 LOG("reading from file failed");
596 errno = EINVAL;
597 return -1;
598 }
599 *offset += request.len;
bellard7a5ca862008-05-27 21:13:40 +0000600
Nick Thomasb2e3d872011-02-22 15:44:51 +0000601 TRACE("Read %u byte(s)", request.len);
bellard7a5ca862008-05-27 21:13:40 +0000602
Nick Thomasb2e3d872011-02-22 15:44:51 +0000603 /* Reply
604 [ 0 .. 3] magic (NBD_REPLY_MAGIC)
605 [ 4 .. 7] error (0 == no error)
606 [ 7 .. 15] handle
607 */
Laurent Vivier5fe16882010-09-17 18:13:57 +0200608
Nick Thomasb2e3d872011-02-22 15:44:51 +0000609 cpu_to_be32w((uint32_t*)data, NBD_REPLY_MAGIC);
610 cpu_to_be32w((uint32_t*)(data + 4), reply.error);
611 cpu_to_be64w((uint64_t*)(data + 8), reply.handle);
bellard7a5ca862008-05-27 21:13:40 +0000612
Nick Thomasb2e3d872011-02-22 15:44:51 +0000613 TRACE("Sending data to client");
bellard7a5ca862008-05-27 21:13:40 +0000614
Nick Thomasb2e3d872011-02-22 15:44:51 +0000615 if (write_sync(csock, data,
616 request.len + NBD_REPLY_SIZE) !=
617 request.len + NBD_REPLY_SIZE) {
618 LOG("writing to socket failed");
619 errno = EINVAL;
620 return -1;
621 }
622 break;
623 case NBD_CMD_WRITE:
624 TRACE("Request type is WRITE");
bellard7a5ca862008-05-27 21:13:40 +0000625
Nick Thomasb2e3d872011-02-22 15:44:51 +0000626 TRACE("Reading %u byte(s)", request.len);
bellard7a5ca862008-05-27 21:13:40 +0000627
Nick Thomasb2e3d872011-02-22 15:44:51 +0000628 if (read_sync(csock, data, request.len) != request.len) {
629 LOG("reading from socket failed");
630 errno = EINVAL;
631 return -1;
632 }
bellard7a5ca862008-05-27 21:13:40 +0000633
Nick Thomasb2e3d872011-02-22 15:44:51 +0000634 if (readonly) {
635 TRACE("Server is read-only, return error");
636 reply.error = 1;
637 } else {
638 TRACE("Writing to device");
bellard7a5ca862008-05-27 21:13:40 +0000639
Nick Thomasb2e3d872011-02-22 15:44:51 +0000640 if (bdrv_write(bs, (request.from + dev_offset) / 512,
641 data, request.len / 512) == -1) {
642 LOG("writing to file failed");
643 errno = EINVAL;
644 return -1;
645 }
bellard7a5ca862008-05-27 21:13:40 +0000646
Nick Thomasb2e3d872011-02-22 15:44:51 +0000647 *offset += request.len;
648 }
bellard7a5ca862008-05-27 21:13:40 +0000649
Nick Thomasb2e3d872011-02-22 15:44:51 +0000650 if (nbd_send_reply(csock, &reply) == -1)
651 return -1;
652 break;
653 case NBD_CMD_DISC:
654 TRACE("Request type is DISCONNECT");
655 errno = 0;
656 return 1;
657 default:
658 LOG("invalid request type (%u) received", request.type);
659 errno = EINVAL;
660 return -1;
661 }
bellard7a5ca862008-05-27 21:13:40 +0000662
Nick Thomasb2e3d872011-02-22 15:44:51 +0000663 TRACE("Request/Reply complete");
bellard7a5ca862008-05-27 21:13:40 +0000664
Nick Thomasb2e3d872011-02-22 15:44:51 +0000665 return 0;
bellard7a5ca862008-05-27 21:13:40 +0000666}