1 /* libguestfs - the guestfsd daemon
2 * Copyright (C) 2009 Red Hat Inc.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 #include <sys/param.h> /* defines MIN */
29 #include <rpc/types.h>
33 #include "../src/guestfs_protocol.h"
35 /* The message currently being processed. */
39 /* The daemon communications socket. */
49 struct guestfs_message_header hdr;
54 /* Read the length word. */
55 xread (sock, lenbuf, 4);
56 xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
57 xdr_uint32_t (&xdr, &len);
60 if (len > GUESTFS_MESSAGE_MAX) {
61 fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
68 reply_with_perror ("malloc");
72 xread (sock, buf, len);
77 for (i = 0; i < len; i += 16) {
79 for (j = i; j < MIN (i+16, len); ++j)
80 printf ("%02x ", (unsigned char) buf[j]);
84 for (j = i; j < MIN (i+16, len); ++j)
86 printf ("%c", buf[j]);
95 /* Decode the message header. */
96 xdrmem_create (&xdr, buf, len, XDR_DECODE);
97 if (!xdr_guestfs_message_header (&xdr, &hdr)) {
98 fprintf (stderr, "guestfsd: could not decode message header\n");
102 /* Check the version etc. */
103 if (hdr.prog != GUESTFS_PROGRAM) {
104 reply_with_error ("wrong program (%d)", hdr.prog);
107 if (hdr.vers != GUESTFS_PROTOCOL_VERSION) {
108 reply_with_error ("wrong protocol version (%d)", hdr.vers);
111 if (hdr.direction != GUESTFS_DIRECTION_CALL) {
112 reply_with_error ("unexpected message direction (%d)", hdr.direction);
115 if (hdr.status != GUESTFS_STATUS_OK) {
116 reply_with_error ("unexpected message status (%d)", hdr.status);
120 /* Now start to process this message. */
123 dispatch_incoming_message (&xdr);
124 /* Note that dispatch_incoming_message will also send a reply. */
132 static void send_error (const char *msg);
135 reply_with_error (const char *fs, ...)
137 char err[GUESTFS_ERROR_LEN];
141 vsnprintf (err, sizeof err, fs, args);
148 reply_with_perror (const char *fs, ...)
150 char buf1[GUESTFS_ERROR_LEN];
151 char buf2[GUESTFS_ERROR_LEN];
156 vsnprintf (buf1, sizeof buf1, fs, args);
159 snprintf (buf2, sizeof buf2, "%s: %s", buf1, strerror (err));
165 send_error (const char *msg)
168 char buf[GUESTFS_ERROR_LEN + 200];
170 struct guestfs_message_header hdr;
171 struct guestfs_message_error err;
174 fprintf (stderr, "guestfsd: error: %s\n", msg);
176 xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
178 hdr.prog = GUESTFS_PROGRAM;
179 hdr.vers = GUESTFS_PROTOCOL_VERSION;
180 hdr.direction = GUESTFS_DIRECTION_REPLY;
181 hdr.status = GUESTFS_STATUS_ERROR;
185 if (!xdr_guestfs_message_header (&xdr, &hdr)) {
186 fprintf (stderr, "guestfsd: failed to encode error message header\n");
190 err.error_message = (char *) msg;
192 if (!xdr_guestfs_message_error (&xdr, &err)) {
193 fprintf (stderr, "guestfsd: failed to encode error message body\n");
197 len = xdr_getpos (&xdr);
200 xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
201 xdr_uint32_t (&xdr, &len);
204 (void) xwrite (sock, lenbuf, 4);
205 (void) xwrite (sock, buf, len);
209 reply (xdrproc_t xdrp, char *ret)
212 char buf[GUESTFS_MESSAGE_MAX];
214 struct guestfs_message_header hdr;
217 xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
219 hdr.prog = GUESTFS_PROGRAM;
220 hdr.vers = GUESTFS_PROTOCOL_VERSION;
221 hdr.direction = GUESTFS_DIRECTION_REPLY;
222 hdr.status = GUESTFS_STATUS_OK;
226 if (!xdr_guestfs_message_header (&xdr, &hdr)) {
227 fprintf (stderr, "guestfsd: failed to encode reply header\n");
232 if (!(*xdrp) (&xdr, ret)) {
233 fprintf (stderr, "guestfsd: failed to encode reply body\n");
238 len = xdr_getpos (&xdr);
241 xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
242 xdr_uint32_t (&xdr, &len);
245 (void) xwrite (sock, lenbuf, 4);
246 (void) xwrite (sock, buf, len);
249 /* Receive file chunks, repeatedly calling 'cb'. */
251 receive_file (receive_cb cb, void *opaque)
261 /* Read the length word. */
262 xread (sock, lenbuf, 4);
263 xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
264 xdr_uint32_t (&xdr, &len);
267 if (len == GUESTFS_CANCEL_FLAG)
268 continue; /* Just ignore it. */
270 if (len > GUESTFS_MESSAGE_MAX) {
271 fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
282 xread (sock, buf, len);
284 xdrmem_create (&xdr, buf, len, XDR_DECODE);
285 memset (&chunk, 0, sizeof chunk);
286 if (!xdr_guestfs_chunk (&xdr, &chunk)) {
295 printf ("receive_file: got chunk: cancel = %d, len = %d, buf = %p\n",
296 chunk.cancel, chunk.data.data_len, chunk.data.data_val);
299 fprintf (stderr, "receive_file: received cancellation from library\n");
300 xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
303 if (chunk.data.data_len == 0) {
304 xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
305 return 0; /* end of file */
309 r = cb (opaque, chunk.data.data_val, chunk.data.data_len);
313 xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
314 if (r == -1) /* write error */
319 /* Send a cancellation flag back to the library. */
321 cancel_receive (void)
325 uint32_t flag = GUESTFS_CANCEL_FLAG;
327 xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE);
328 xdr_uint32_t (&xdr, &flag);
331 if (xwrite (sock, fbuf, sizeof fbuf) == -1) {
332 perror ("write to socket");
336 /* Keep receiving chunks and discarding, until library sees cancel. */
337 (void) receive_file (NULL, NULL);
340 static int check_for_library_cancellation (void);
341 static int send_chunk (const guestfs_chunk *);
343 /* Also check if the library sends us a cancellation message. */
345 send_file_write (const void *buf, int len)
350 if (len > GUESTFS_MAX_CHUNK_SIZE) {
351 fprintf (stderr, "send_file_write: len (%d) > GUESTFS_MAX_CHUNK_SIZE (%d)\n",
352 len, GUESTFS_MAX_CHUNK_SIZE);
356 cancel = check_for_library_cancellation ();
360 chunk.data.data_len = 0;
361 chunk.data.data_val = NULL;
364 chunk.data.data_len = len;
365 chunk.data.data_val = (char *) buf;
368 if (send_chunk (&chunk) == -1)
371 if (cancel) return -2;
376 check_for_library_cancellation (void)
386 FD_SET (sock, &rset);
389 r = select (sock+1, &rset, NULL, NULL, &tv);
397 /* Read the message from the daemon. */
398 r = xread (sock, buf, sizeof buf);
404 xdrmem_create (&xdr, buf, sizeof buf, XDR_DECODE);
405 xdr_uint32_t (&xdr, &flag);
408 if (flag != GUESTFS_CANCEL_FLAG) {
409 fprintf (stderr, "check_for_library_cancellation: read 0x%x from library, expected 0x%x\n",
410 flag, GUESTFS_CANCEL_FLAG);
418 send_file_end (int cancel)
422 chunk.cancel = cancel;
423 chunk.data.data_len = 0;
424 chunk.data.data_val = NULL;
429 send_chunk (const guestfs_chunk *chunk)
431 char buf[GUESTFS_MAX_CHUNK_SIZE + 48];
436 xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
437 if (!xdr_guestfs_chunk (&xdr, (guestfs_chunk *) chunk)) {
438 fprintf (stderr, "send_chunk: failed to encode chunk\n");
443 len = xdr_getpos (&xdr);
446 xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
447 xdr_uint32_t (&xdr, &len);
450 (void) xwrite (sock, lenbuf, 4);
451 (void) xwrite (sock, buf, len);