1 /*
2  * QEMU System Emulator
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 #include "qemu/osdep.h"
25 #include <zlib.h>
26 #include "qemu/error-report.h"
27 #include "qemu/iov.h"
28 #include "migration.h"
29 #include "qemu-file.h"
30 #include "trace.h"
31 #include "qapi/error.h"
32 
33 #define IO_BUF_SIZE 32768
34 #define MAX_IOV_SIZE MIN(IOV_MAX, 64)
35 
36 struct QEMUFile {
37     const QEMUFileOps *ops;
38     const QEMUFileHooks *hooks;
39     void *opaque;
40 
41     int64_t bytes_xfer;
42     int64_t xfer_limit;
43 
44     int64_t pos; /* start of buffer when writing, end of buffer
45                     when reading */
46     int buf_index;
47     int buf_size; /* 0 when writing */
48     uint8_t buf[IO_BUF_SIZE];
49 
50     DECLARE_BITMAP(may_free, MAX_IOV_SIZE);
51     struct iovec iov[MAX_IOV_SIZE];
52     unsigned int iovcnt;
53 
54     int last_error;
55     Error *last_error_obj;
56     /* has the file has been shutdown */
57     bool shutdown;
58 };
59 
60 /*
61  * Stop a file from being read/written - not all backing files can do this
62  * typically only sockets can.
63  */
64 int qemu_file_shutdown(QEMUFile *f)
65 {
66     int ret;
67 
68     f->shutdown = true;
69     if (!f->ops->shut_down) {
70         return -ENOSYS;
71     }
72     ret = f->ops->shut_down(f->opaque, true, true, NULL);
73 
74     if (!f->last_error) {
75         qemu_file_set_error(f, -EIO);
76     }
77     return ret;
78 }
79 
80 /*
81  * Result: QEMUFile* for a 'return path' for comms in the opposite direction
82  *         NULL if not available
83  */
84 QEMUFile *qemu_file_get_return_path(QEMUFile *f)
85 {
86     if (!f->ops->get_return_path) {
87         return NULL;
88     }
89     return f->ops->get_return_path(f->opaque);
90 }
91 
92 bool qemu_file_mode_is_not_valid(const char *mode)
93 {
94     if (mode == NULL ||
95         (mode[0] != 'r' && mode[0] != 'w') ||
96         mode[1] != 'b' || mode[2] != 0) {
97         fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
98         return true;
99     }
100 
101     return false;
102 }
103 
104 QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
105 {
106     QEMUFile *f;
107 
108     f = g_new0(QEMUFile, 1);
109 
110     f->opaque = opaque;
111     f->ops = ops;
112     return f;
113 }
114 
115 
116 void qemu_file_set_hooks(QEMUFile *f, const QEMUFileHooks *hooks)
117 {
118     f->hooks = hooks;
119 }
120 
121 /*
122  * Get last error for stream f with optional Error*
123  *
124  * Return negative error value if there has been an error on previous
125  * operations, return 0 if no error happened.
126  * Optional, it returns Error* in errp, but it may be NULL even if return value
127  * is not 0.
128  *
129  */
130 int qemu_file_get_error_obj(QEMUFile *f, Error **errp)
131 {
132     if (errp) {
133         *errp = f->last_error_obj ? error_copy(f->last_error_obj) : NULL;
134     }
135     return f->last_error;
136 }
137 
138 /*
139  * Set the last error for stream f with optional Error*
140  */
141 void qemu_file_set_error_obj(QEMUFile *f, int ret, Error *err)
142 {
143     if (f->last_error == 0 && ret) {
144         f->last_error = ret;
145         error_propagate(&f->last_error_obj, err);
146     } else if (err) {
147         error_report_err(err);
148     }
149 }
150 
151 /*
152  * Get last error for stream f
153  *
154  * Return negative error value if there has been an error on previous
155  * operations, return 0 if no error happened.
156  *
157  */
158 int qemu_file_get_error(QEMUFile *f)
159 {
160     return qemu_file_get_error_obj(f, NULL);
161 }
162 
163 /*
164  * Set the last error for stream f
165  */
166 void qemu_file_set_error(QEMUFile *f, int ret)
167 {
168     qemu_file_set_error_obj(f, ret, NULL);
169 }
170 
171 bool qemu_file_is_writable(QEMUFile *f)
172 {
173     return f->ops->writev_buffer;
174 }
175 
176 static void qemu_iovec_release_ram(QEMUFile *f)
177 {
178     struct iovec iov;
179     unsigned long idx;
180 
181     /* Find and release all the contiguous memory ranges marked as may_free. */
182     idx = find_next_bit(f->may_free, f->iovcnt, 0);
183     if (idx >= f->iovcnt) {
184         return;
185     }
186     iov = f->iov[idx];
187 
188     /* The madvise() in the loop is called for iov within a continuous range and
189      * then reinitialize the iov. And in the end, madvise() is called for the
190      * last iov.
191      */
192     while ((idx = find_next_bit(f->may_free, f->iovcnt, idx + 1)) < f->iovcnt) {
193         /* check for adjacent buffer and coalesce them */
194         if (iov.iov_base + iov.iov_len == f->iov[idx].iov_base) {
195             iov.iov_len += f->iov[idx].iov_len;
196             continue;
197         }
198         if (qemu_madvise(iov.iov_base, iov.iov_len, QEMU_MADV_DONTNEED) < 0) {
199             error_report("migrate: madvise DONTNEED failed %p %zd: %s",
200                          iov.iov_base, iov.iov_len, strerror(errno));
201         }
202         iov = f->iov[idx];
203     }
204     if (qemu_madvise(iov.iov_base, iov.iov_len, QEMU_MADV_DONTNEED) < 0) {
205             error_report("migrate: madvise DONTNEED failed %p %zd: %s",
206                          iov.iov_base, iov.iov_len, strerror(errno));
207     }
208     memset(f->may_free, 0, sizeof(f->may_free));
209 }
210 
211 /**
212  * Flushes QEMUFile buffer
213  *
214  * This will flush all pending data. If data was only partially flushed, it
215  * will set an error state.
216  */
217 void qemu_fflush(QEMUFile *f)
218 {
219     ssize_t ret = 0;
220     ssize_t expect = 0;
221     Error *local_error = NULL;
222 
223     if (!qemu_file_is_writable(f)) {
224         return;
225     }
226 
227     if (f->shutdown) {
228         return;
229     }
230     if (f->iovcnt > 0) {
231         expect = iov_size(f->iov, f->iovcnt);
232         ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos,
233                                     &local_error);
234 
235         qemu_iovec_release_ram(f);
236     }
237 
238     if (ret >= 0) {
239         f->pos += ret;
240     }
241     /* We expect the QEMUFile write impl to send the full
242      * data set we requested, so sanity check that.
243      */
244     if (ret != expect) {
245         qemu_file_set_error_obj(f, ret < 0 ? ret : -EIO, local_error);
246     }
247     f->buf_index = 0;
248     f->iovcnt = 0;
249 }
250 
251 void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
252 {
253     int ret = 0;
254 
255     if (f->hooks && f->hooks->before_ram_iterate) {
256         ret = f->hooks->before_ram_iterate(f, f->opaque, flags, NULL);
257         if (ret < 0) {
258             qemu_file_set_error(f, ret);
259         }
260     }
261 }
262 
263 void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
264 {
265     int ret = 0;
266 
267     if (f->hooks && f->hooks->after_ram_iterate) {
268         ret = f->hooks->after_ram_iterate(f, f->opaque, flags, NULL);
269         if (ret < 0) {
270             qemu_file_set_error(f, ret);
271         }
272     }
273 }
274 
275 void ram_control_load_hook(QEMUFile *f, uint64_t flags, void *data)
276 {
277     int ret = -EINVAL;
278 
279     if (f->hooks && f->hooks->hook_ram_load) {
280         ret = f->hooks->hook_ram_load(f, f->opaque, flags, data);
281         if (ret < 0) {
282             qemu_file_set_error(f, ret);
283         }
284     } else {
285         /*
286          * Hook is a hook specifically requested by the source sending a flag
287          * that expects there to be a hook on the destination.
288          */
289         if (flags == RAM_CONTROL_HOOK) {
290             qemu_file_set_error(f, ret);
291         }
292     }
293 }
294 
295 size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
296                              ram_addr_t offset, size_t size,
297                              uint64_t *bytes_sent)
298 {
299     if (f->hooks && f->hooks->save_page) {
300         int ret = f->hooks->save_page(f, f->opaque, block_offset,
301                                       offset, size, bytes_sent);
302         if (ret != RAM_SAVE_CONTROL_NOT_SUPP) {
303             f->bytes_xfer += size;
304         }
305 
306         if (ret != RAM_SAVE_CONTROL_DELAYED &&
307             ret != RAM_SAVE_CONTROL_NOT_SUPP) {
308             if (bytes_sent && *bytes_sent > 0) {
309                 qemu_update_position(f, *bytes_sent);
310             } else if (ret < 0) {
311                 qemu_file_set_error(f, ret);
312             }
313         }
314 
315         return ret;
316     }
317 
318     return RAM_SAVE_CONTROL_NOT_SUPP;
319 }
320 
321 /*
322  * Attempt to fill the buffer from the underlying file
323  * Returns the number of bytes read, or negative value for an error.
324  *
325  * Note that it can return a partially full buffer even in a not error/not EOF
326  * case if the underlying file descriptor gives a short read, and that can
327  * happen even on a blocking fd.
328  */
329 static ssize_t qemu_fill_buffer(QEMUFile *f)
330 {
331     int len;
332     int pending;
333     Error *local_error = NULL;
334 
335     assert(!qemu_file_is_writable(f));
336 
337     pending = f->buf_size - f->buf_index;
338     if (pending > 0) {
339         memmove(f->buf, f->buf + f->buf_index, pending);
340     }
341     f->buf_index = 0;
342     f->buf_size = pending;
343 
344     if (f->shutdown) {
345         return 0;
346     }
347 
348     len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
349                              IO_BUF_SIZE - pending, &local_error);
350     if (len > 0) {
351         f->buf_size += len;
352         f->pos += len;
353     } else if (len == 0) {
354         qemu_file_set_error_obj(f, -EIO, local_error);
355     } else if (len != -EAGAIN) {
356         qemu_file_set_error_obj(f, len, local_error);
357     } else {
358         error_free(local_error);
359     }
360 
361     return len;
362 }
363 
364 void qemu_update_position(QEMUFile *f, size_t size)
365 {
366     f->pos += size;
367 }
368 
369 /** Closes the file
370  *
371  * Returns negative error value if any error happened on previous operations or
372  * while closing the file. Returns 0 or positive number on success.
373  *
374  * The meaning of return value on success depends on the specific backend
375  * being used.
376  */
377 int qemu_fclose(QEMUFile *f)
378 {
379     int ret;
380     qemu_fflush(f);
381     ret = qemu_file_get_error(f);
382 
383     if (f->ops->close) {
384         int ret2 = f->ops->close(f->opaque, NULL);
385         if (ret >= 0) {
386             ret = ret2;
387         }
388     }
389     /* If any error was spotted before closing, we should report it
390      * instead of the close() return value.
391      */
392     if (f->last_error) {
393         ret = f->last_error;
394     }
395     error_free(f->last_error_obj);
396     g_free(f);
397     trace_qemu_file_fclose();
398     return ret;
399 }
400 
401 /*
402  * Add buf to iovec. Do flush if iovec is full.
403  *
404  * Return values:
405  * 1 iovec is full and flushed
406  * 0 iovec is not flushed
407  *
408  */
409 static int add_to_iovec(QEMUFile *f, const uint8_t *buf, size_t size,
410                         bool may_free)
411 {
412     /* check for adjacent buffer and coalesce them */
413     if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
414         f->iov[f->iovcnt - 1].iov_len &&
415         may_free == test_bit(f->iovcnt - 1, f->may_free))
416     {
417         f->iov[f->iovcnt - 1].iov_len += size;
418     } else {
419         if (may_free) {
420             set_bit(f->iovcnt, f->may_free);
421         }
422         f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
423         f->iov[f->iovcnt++].iov_len = size;
424     }
425 
426     if (f->iovcnt >= MAX_IOV_SIZE) {
427         qemu_fflush(f);
428         return 1;
429     }
430 
431     return 0;
432 }
433 
434 static void add_buf_to_iovec(QEMUFile *f, size_t len)
435 {
436     if (!add_to_iovec(f, f->buf + f->buf_index, len, false)) {
437         f->buf_index += len;
438         if (f->buf_index == IO_BUF_SIZE) {
439             qemu_fflush(f);
440         }
441     }
442 }
443 
444 void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size,
445                            bool may_free)
446 {
447     if (f->last_error) {
448         return;
449     }
450 
451     f->bytes_xfer += size;
452     add_to_iovec(f, buf, size, may_free);
453 }
454 
455 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size)
456 {
457     size_t l;
458 
459     if (f->last_error) {
460         return;
461     }
462 
463     while (size > 0) {
464         l = IO_BUF_SIZE - f->buf_index;
465         if (l > size) {
466             l = size;
467         }
468         memcpy(f->buf + f->buf_index, buf, l);
469         f->bytes_xfer += l;
470         add_buf_to_iovec(f, l);
471         if (qemu_file_get_error(f)) {
472             break;
473         }
474         buf += l;
475         size -= l;
476     }
477 }
478 
479 void qemu_put_byte(QEMUFile *f, int v)
480 {
481     if (f->last_error) {
482         return;
483     }
484 
485     f->buf[f->buf_index] = v;
486     f->bytes_xfer++;
487     add_buf_to_iovec(f, 1);
488 }
489 
490 void qemu_file_skip(QEMUFile *f, int size)
491 {
492     if (f->buf_index + size <= f->buf_size) {
493         f->buf_index += size;
494     }
495 }
496 
497 /*
498  * Read 'size' bytes from file (at 'offset') without moving the
499  * pointer and set 'buf' to point to that data.
500  *
501  * It will return size bytes unless there was an error, in which case it will
502  * return as many as it managed to read (assuming blocking fd's which
503  * all current QEMUFile are)
504  */
505 size_t qemu_peek_buffer(QEMUFile *f, uint8_t **buf, size_t size, size_t offset)
506 {
507     ssize_t pending;
508     size_t index;
509 
510     assert(!qemu_file_is_writable(f));
511     assert(offset < IO_BUF_SIZE);
512     assert(size <= IO_BUF_SIZE - offset);
513 
514     /* The 1st byte to read from */
515     index = f->buf_index + offset;
516     /* The number of available bytes starting at index */
517     pending = f->buf_size - index;
518 
519     /*
520      * qemu_fill_buffer might return just a few bytes, even when there isn't
521      * an error, so loop collecting them until we get enough.
522      */
523     while (pending < size) {
524         int received = qemu_fill_buffer(f);
525 
526         if (received <= 0) {
527             break;
528         }
529 
530         index = f->buf_index + offset;
531         pending = f->buf_size - index;
532     }
533 
534     if (pending <= 0) {
535         return 0;
536     }
537     if (size > pending) {
538         size = pending;
539     }
540 
541     *buf = f->buf + index;
542     return size;
543 }
544 
545 /*
546  * Read 'size' bytes of data from the file into buf.
547  * 'size' can be larger than the internal buffer.
548  *
549  * It will return size bytes unless there was an error, in which case it will
550  * return as many as it managed to read (assuming blocking fd's which
551  * all current QEMUFile are)
552  */
553 size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size)
554 {
555     size_t pending = size;
556     size_t done = 0;
557 
558     while (pending > 0) {
559         size_t res;
560         uint8_t *src;
561 
562         res = qemu_peek_buffer(f, &src, MIN(pending, IO_BUF_SIZE), 0);
563         if (res == 0) {
564             return done;
565         }
566         memcpy(buf, src, res);
567         qemu_file_skip(f, res);
568         buf += res;
569         pending -= res;
570         done += res;
571     }
572     return done;
573 }
574 
575 /*
576  * Read 'size' bytes of data from the file.
577  * 'size' can be larger than the internal buffer.
578  *
579  * The data:
580  *   may be held on an internal buffer (in which case *buf is updated
581  *     to point to it) that is valid until the next qemu_file operation.
582  * OR
583  *   will be copied to the *buf that was passed in.
584  *
585  * The code tries to avoid the copy if possible.
586  *
587  * It will return size bytes unless there was an error, in which case it will
588  * return as many as it managed to read (assuming blocking fd's which
589  * all current QEMUFile are)
590  *
591  * Note: Since **buf may get changed, the caller should take care to
592  *       keep a pointer to the original buffer if it needs to deallocate it.
593  */
594 size_t qemu_get_buffer_in_place(QEMUFile *f, uint8_t **buf, size_t size)
595 {
596     if (size < IO_BUF_SIZE) {
597         size_t res;
598         uint8_t *src;
599 
600         res = qemu_peek_buffer(f, &src, size, 0);
601 
602         if (res == size) {
603             qemu_file_skip(f, res);
604             *buf = src;
605             return res;
606         }
607     }
608 
609     return qemu_get_buffer(f, *buf, size);
610 }
611 
612 /*
613  * Peeks a single byte from the buffer; this isn't guaranteed to work if
614  * offset leaves a gap after the previous read/peeked data.
615  */
616 int qemu_peek_byte(QEMUFile *f, int offset)
617 {
618     int index = f->buf_index + offset;
619 
620     assert(!qemu_file_is_writable(f));
621     assert(offset < IO_BUF_SIZE);
622 
623     if (index >= f->buf_size) {
624         qemu_fill_buffer(f);
625         index = f->buf_index + offset;
626         if (index >= f->buf_size) {
627             return 0;
628         }
629     }
630     return f->buf[index];
631 }
632 
633 int qemu_get_byte(QEMUFile *f)
634 {
635     int result;
636 
637     result = qemu_peek_byte(f, 0);
638     qemu_file_skip(f, 1);
639     return result;
640 }
641 
642 int64_t qemu_ftell_fast(QEMUFile *f)
643 {
644     int64_t ret = f->pos;
645     int i;
646 
647     for (i = 0; i < f->iovcnt; i++) {
648         ret += f->iov[i].iov_len;
649     }
650 
651     return ret;
652 }
653 
654 int64_t qemu_ftell(QEMUFile *f)
655 {
656     qemu_fflush(f);
657     return f->pos;
658 }
659 
660 int qemu_file_rate_limit(QEMUFile *f)
661 {
662     if (f->shutdown) {
663         return 1;
664     }
665     if (qemu_file_get_error(f)) {
666         return 1;
667     }
668     if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
669         return 1;
670     }
671     return 0;
672 }
673 
674 int64_t qemu_file_get_rate_limit(QEMUFile *f)
675 {
676     return f->xfer_limit;
677 }
678 
679 void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
680 {
681     f->xfer_limit = limit;
682 }
683 
684 void qemu_file_reset_rate_limit(QEMUFile *f)
685 {
686     f->bytes_xfer = 0;
687 }
688 
689 void qemu_file_update_transfer(QEMUFile *f, int64_t len)
690 {
691     f->bytes_xfer += len;
692 }
693 
694 void qemu_put_be16(QEMUFile *f, unsigned int v)
695 {
696     qemu_put_byte(f, v >> 8);
697     qemu_put_byte(f, v);
698 }
699 
700 void qemu_put_be32(QEMUFile *f, unsigned int v)
701 {
702     qemu_put_byte(f, v >> 24);
703     qemu_put_byte(f, v >> 16);
704     qemu_put_byte(f, v >> 8);
705     qemu_put_byte(f, v);
706 }
707 
708 void qemu_put_be64(QEMUFile *f, uint64_t v)
709 {
710     qemu_put_be32(f, v >> 32);
711     qemu_put_be32(f, v);
712 }
713 
714 unsigned int qemu_get_be16(QEMUFile *f)
715 {
716     unsigned int v;
717     v = qemu_get_byte(f) << 8;
718     v |= qemu_get_byte(f);
719     return v;
720 }
721 
722 unsigned int qemu_get_be32(QEMUFile *f)
723 {
724     unsigned int v;
725     v = (unsigned int)qemu_get_byte(f) << 24;
726     v |= qemu_get_byte(f) << 16;
727     v |= qemu_get_byte(f) << 8;
728     v |= qemu_get_byte(f);
729     return v;
730 }
731 
732 uint64_t qemu_get_be64(QEMUFile *f)
733 {
734     uint64_t v;
735     v = (uint64_t)qemu_get_be32(f) << 32;
736     v |= qemu_get_be32(f);
737     return v;
738 }
739 
740 /* return the size after compression, or negative value on error */
741 static int qemu_compress_data(z_stream *stream, uint8_t *dest, size_t dest_len,
742                               const uint8_t *source, size_t source_len)
743 {
744     int err;
745 
746     err = deflateReset(stream);
747     if (err != Z_OK) {
748         return -1;
749     }
750 
751     stream->avail_in = source_len;
752     stream->next_in = (uint8_t *)source;
753     stream->avail_out = dest_len;
754     stream->next_out = dest;
755 
756     err = deflate(stream, Z_FINISH);
757     if (err != Z_STREAM_END) {
758         return -1;
759     }
760 
761     return stream->next_out - dest;
762 }
763 
764 /* Compress size bytes of data start at p and store the compressed
765  * data to the buffer of f.
766  *
767  * Since the file is dummy file with empty_ops, return -1 if f has no space to
768  * save the compressed data.
769  */
770 ssize_t qemu_put_compression_data(QEMUFile *f, z_stream *stream,
771                                   const uint8_t *p, size_t size)
772 {
773     ssize_t blen = IO_BUF_SIZE - f->buf_index - sizeof(int32_t);
774 
775     if (blen < compressBound(size)) {
776         return -1;
777     }
778 
779     blen = qemu_compress_data(stream, f->buf + f->buf_index + sizeof(int32_t),
780                               blen, p, size);
781     if (blen < 0) {
782         return -1;
783     }
784 
785     qemu_put_be32(f, blen);
786     add_buf_to_iovec(f, blen);
787     return blen + sizeof(int32_t);
788 }
789 
790 /* Put the data in the buffer of f_src to the buffer of f_des, and
791  * then reset the buf_index of f_src to 0.
792  */
793 
794 int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src)
795 {
796     int len = 0;
797 
798     if (f_src->buf_index > 0) {
799         len = f_src->buf_index;
800         qemu_put_buffer(f_des, f_src->buf, f_src->buf_index);
801         f_src->buf_index = 0;
802         f_src->iovcnt = 0;
803     }
804     return len;
805 }
806 
807 /*
808  * Get a string whose length is determined by a single preceding byte
809  * A preallocated 256 byte buffer must be passed in.
810  * Returns: len on success and a 0 terminated string in the buffer
811  *          else 0
812  *          (Note a 0 length string will return 0 either way)
813  */
814 size_t qemu_get_counted_string(QEMUFile *f, char buf[256])
815 {
816     size_t len = qemu_get_byte(f);
817     size_t res = qemu_get_buffer(f, (uint8_t *)buf, len);
818 
819     buf[res] = 0;
820 
821     return res == len ? res : 0;
822 }
823 
824 /*
825  * Put a string with one preceding byte containing its length. The length of
826  * the string should be less than 256.
827  */
828 void qemu_put_counted_string(QEMUFile *f, const char *str)
829 {
830     size_t len = strlen(str);
831 
832     assert(len < 256);
833     qemu_put_byte(f, len);
834     qemu_put_buffer(f, (const uint8_t *)str, len);
835 }
836 
837 /*
838  * Set the blocking state of the QEMUFile.
839  * Note: On some transports the OS only keeps a single blocking state for
840  *       both directions, and thus changing the blocking on the main
841  *       QEMUFile can also affect the return path.
842  */
843 void qemu_file_set_blocking(QEMUFile *f, bool block)
844 {
845     if (f->ops->set_blocking) {
846         f->ops->set_blocking(f->opaque, block, NULL);
847     }
848 }
849