c22bbee4744abfbd28acafba255652a729b16969
[libguestfs.git] / daemon / proto.c
1 /* libguestfs - the guestfsd daemon
2  * Copyright (C) 2009 Red Hat Inc.
3  *
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.
8  *
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.
13  *
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.
17  */
18
19 #include <config.h>
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <stdarg.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <errno.h>
27 #include <ctype.h>
28 #include <sys/param.h>          /* defines MIN */
29 #include <rpc/types.h>
30 #include <rpc/xdr.h>
31
32 #include "ignore-value.h"
33
34 #include "daemon.h"
35 #include "../src/guestfs_protocol.h"
36
37 /* The message currently being processed. */
38 int proc_nr;
39 int serial;
40
41 /* The daemon communications socket. */
42 static int sock;
43
44 void
45 main_loop (int _sock)
46 {
47   XDR xdr;
48   char *buf;
49   char lenbuf[4];
50   uint32_t len;
51   struct guestfs_message_header hdr;
52   struct timeval start_t, end_t;
53   int64_t start_us, end_us, elapsed_us;
54
55   sock = _sock;
56
57   for (;;) {
58     /* Most common errors are leaked memory and leaked file descriptors,
59      * so run this between each command:
60      */
61     if (verbose && 0)
62       ignore_value (system ("ls -l /proc/self/fd"));
63
64     /* Read the length word. */
65     if (xread (sock, lenbuf, 4) == -1)
66       exit (1);
67
68     xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
69     xdr_uint32_t (&xdr, &len);
70     xdr_destroy (&xdr);
71
72     if (len > GUESTFS_MESSAGE_MAX) {
73       fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
74                len);
75       exit (1);
76     }
77
78     buf = malloc (len);
79     if (!buf) {
80       reply_with_perror ("malloc");
81       continue;
82     }
83
84     if (xread (sock, buf, len) == -1)
85       exit (1);
86
87 #ifdef ENABLE_PACKET_DUMP
88     if (verbose) {
89       size_t i, j;
90
91       for (i = 0; i < len; i += 16) {
92         printf ("%04zx: ", i);
93         for (j = i; j < MIN (i+16, len); ++j)
94           printf ("%02x ", (unsigned char) buf[j]);
95         for (; j < i+16; ++j)
96           printf ("   ");
97         printf ("|");
98         for (j = i; j < MIN (i+16, len); ++j)
99           if (isprint (buf[j]))
100             printf ("%c", buf[j]);
101           else
102             printf (".");
103         for (; j < i+16; ++j)
104           printf (" ");
105         printf ("|\n");
106       }
107     }
108 #endif
109
110     /* In verbose mode, display the time taken to run each command. */
111     if (verbose)
112       gettimeofday (&start_t, NULL);
113
114     /* Decode the message header. */
115     xdrmem_create (&xdr, buf, len, XDR_DECODE);
116     if (!xdr_guestfs_message_header (&xdr, &hdr)) {
117       fprintf (stderr, "guestfsd: could not decode message header\n");
118       exit (1);
119     }
120
121     /* Check the version etc. */
122     if (hdr.prog != GUESTFS_PROGRAM) {
123       reply_with_error ("wrong program (%d)", hdr.prog);
124       goto cont;
125     }
126     if (hdr.vers != GUESTFS_PROTOCOL_VERSION) {
127       reply_with_error ("wrong protocol version (%d)", hdr.vers);
128       goto cont;
129     }
130     if (hdr.direction != GUESTFS_DIRECTION_CALL) {
131       reply_with_error ("unexpected message direction (%d)", hdr.direction);
132       goto cont;
133     }
134     if (hdr.status != GUESTFS_STATUS_OK) {
135       reply_with_error ("unexpected message status (%d)", hdr.status);
136       goto cont;
137     }
138
139     /* Now start to process this message. */
140     proc_nr = hdr.proc;
141     serial = hdr.serial;
142     dispatch_incoming_message (&xdr);
143     /* Note that dispatch_incoming_message will also send a reply. */
144
145     /* In verbose mode, display the time taken to run each command. */
146     if (verbose) {
147       gettimeofday (&end_t, NULL);
148
149       start_us = (int64_t) start_t.tv_sec * 1000000 + start_t.tv_usec;
150       end_us = (int64_t) end_t.tv_sec * 1000000 + end_t.tv_usec;
151       elapsed_us = end_us - start_us;
152       fprintf (stderr, "proc %d (%s) took %d.%02d seconds\n",
153                proc_nr,
154                proc_nr >= 0 && proc_nr < GUESTFS_PROC_NR_PROCS
155                ? function_names[proc_nr] : "UNKNOWN PROCEDURE",
156                (int) (elapsed_us / 1000000),
157                (int) ((elapsed_us / 10000) % 100));
158     }
159
160   cont:
161     xdr_destroy (&xdr);
162     free (buf);
163   }
164 }
165
166 static void send_error (const char *msg);
167
168 void
169 reply_with_error (const char *fs, ...)
170 {
171   char err[GUESTFS_ERROR_LEN];
172   va_list args;
173
174   va_start (args, fs);
175   vsnprintf (err, sizeof err, fs, args);
176   va_end (args);
177
178   send_error (err);
179 }
180
181 void
182 reply_with_perror (const char *fs, ...)
183 {
184   char buf1[GUESTFS_ERROR_LEN];
185   char buf2[GUESTFS_ERROR_LEN];
186   va_list args;
187   int err = errno;
188
189   va_start (args, fs);
190   vsnprintf (buf1, sizeof buf1, fs, args);
191   va_end (args);
192
193   snprintf (buf2, sizeof buf2, "%s: %s", buf1, strerror (err));
194
195   send_error (buf2);
196 }
197
198 static void
199 send_error (const char *msg)
200 {
201   XDR xdr;
202   char buf[GUESTFS_ERROR_LEN + 200];
203   char lenbuf[4];
204   struct guestfs_message_header hdr;
205   struct guestfs_message_error err;
206   unsigned len;
207
208   fprintf (stderr, "guestfsd: error: %s\n", msg);
209
210   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
211
212   hdr.prog = GUESTFS_PROGRAM;
213   hdr.vers = GUESTFS_PROTOCOL_VERSION;
214   hdr.direction = GUESTFS_DIRECTION_REPLY;
215   hdr.status = GUESTFS_STATUS_ERROR;
216   hdr.proc = proc_nr;
217   hdr.serial = serial;
218
219   if (!xdr_guestfs_message_header (&xdr, &hdr)) {
220     fprintf (stderr, "guestfsd: failed to encode error message header\n");
221     exit (1);
222   }
223
224   err.error_message = (char *) msg;
225
226   if (!xdr_guestfs_message_error (&xdr, &err)) {
227     fprintf (stderr, "guestfsd: failed to encode error message body\n");
228     exit (1);
229   }
230
231   len = xdr_getpos (&xdr);
232   xdr_destroy (&xdr);
233
234   xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
235   xdr_uint32_t (&xdr, &len);
236   xdr_destroy (&xdr);
237
238   if (xwrite (sock, lenbuf, 4) == -1) {
239     fprintf (stderr, "xwrite failed\n");
240     exit (1);
241   }
242   if (xwrite (sock, buf, len) == -1) {
243     fprintf (stderr, "xwrite failed\n");
244     exit (1);
245   }
246 }
247
248 void
249 reply (xdrproc_t xdrp, char *ret)
250 {
251   XDR xdr;
252   char buf[GUESTFS_MESSAGE_MAX];
253   char lenbuf[4];
254   struct guestfs_message_header hdr;
255   unsigned len;
256
257   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
258
259   hdr.prog = GUESTFS_PROGRAM;
260   hdr.vers = GUESTFS_PROTOCOL_VERSION;
261   hdr.direction = GUESTFS_DIRECTION_REPLY;
262   hdr.status = GUESTFS_STATUS_OK;
263   hdr.proc = proc_nr;
264   hdr.serial = serial;
265
266   if (!xdr_guestfs_message_header (&xdr, &hdr)) {
267     fprintf (stderr, "guestfsd: failed to encode reply header\n");
268     exit (1);
269   }
270
271   if (xdrp) {
272     /* This can fail if the reply body is too large, for example
273      * if it exceeds the maximum message size.  In that case
274      * we want to return an error message instead. (RHBZ#509597).
275      */
276     if (!(*xdrp) (&xdr, ret)) {
277       reply_with_perror ("guestfsd: failed to encode reply body\n");
278       xdr_destroy (&xdr);
279       return;
280     }
281   }
282
283   len = xdr_getpos (&xdr);
284   xdr_destroy (&xdr);
285
286   xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
287   xdr_uint32_t (&xdr, &len);
288   xdr_destroy (&xdr);
289
290   if (xwrite (sock, lenbuf, 4) == -1) {
291     fprintf (stderr, "xwrite failed\n");
292     exit (1);
293   }
294   if (xwrite (sock, buf, len) == -1) {
295     fprintf (stderr, "xwrite failed\n");
296     exit (1);
297   }
298 }
299
300 /* Receive file chunks, repeatedly calling 'cb'. */
301 int
302 receive_file (receive_cb cb, void *opaque)
303 {
304   guestfs_chunk chunk;
305   char lenbuf[4];
306   char *buf;
307   XDR xdr;
308   int r;
309   uint32_t len;
310
311   for (;;) {
312     /* Read the length word. */
313     if (xread (sock, lenbuf, 4) == -1)
314       exit (1);
315
316     xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
317     xdr_uint32_t (&xdr, &len);
318     xdr_destroy (&xdr);
319
320     if (len == GUESTFS_CANCEL_FLAG)
321       continue;                 /* Just ignore it. */
322
323     if (len > GUESTFS_MESSAGE_MAX) {
324       fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
325                len);
326       exit (1);
327     }
328
329     buf = malloc (len);
330     if (!buf) {
331       perror ("malloc");
332       return -1;
333     }
334
335     if (xread (sock, buf, len) == -1)
336       exit (1);
337
338     xdrmem_create (&xdr, buf, len, XDR_DECODE);
339     memset (&chunk, 0, sizeof chunk);
340     if (!xdr_guestfs_chunk (&xdr, &chunk)) {
341       xdr_destroy (&xdr);
342       free (buf);
343       return -1;
344     }
345     xdr_destroy (&xdr);
346     free (buf);
347
348     if (verbose)
349       printf ("receive_file: got chunk: cancel = %d, len = %d, buf = %p\n",
350               chunk.cancel, chunk.data.data_len, chunk.data.data_val);
351
352     if (chunk.cancel) {
353       fprintf (stderr, "receive_file: received cancellation from library\n");
354       xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
355       return -2;
356     }
357     if (chunk.data.data_len == 0) {
358       xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
359       return 0;                 /* end of file */
360     }
361
362     if (cb)
363       r = cb (opaque, chunk.data.data_val, chunk.data.data_len);
364     else
365       r = 0;
366
367     xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
368     if (r == -1)                /* write error */
369       return -1;
370   }
371 }
372
373 /* Send a cancellation flag back to the library. */
374 void
375 cancel_receive (void)
376 {
377   XDR xdr;
378   char fbuf[4];
379   uint32_t flag = GUESTFS_CANCEL_FLAG;
380
381   xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE);
382   xdr_uint32_t (&xdr, &flag);
383   xdr_destroy (&xdr);
384
385   if (xwrite (sock, fbuf, sizeof fbuf) == -1) {
386     perror ("write to socket");
387     return;
388   }
389
390   /* Keep receiving chunks and discarding, until library sees cancel. */
391   (void) receive_file (NULL, NULL);
392 }
393
394 static int check_for_library_cancellation (void);
395 static int send_chunk (const guestfs_chunk *);
396
397 /* Also check if the library sends us a cancellation message. */
398 int
399 send_file_write (const void *buf, int len)
400 {
401   guestfs_chunk chunk;
402   int cancel;
403
404   if (len > GUESTFS_MAX_CHUNK_SIZE) {
405     fprintf (stderr, "send_file_write: len (%d) > GUESTFS_MAX_CHUNK_SIZE (%d)\n",
406              len, GUESTFS_MAX_CHUNK_SIZE);
407     return -1;
408   }
409
410   cancel = check_for_library_cancellation ();
411
412   if (cancel) {
413     chunk.cancel = 1;
414     chunk.data.data_len = 0;
415     chunk.data.data_val = NULL;
416   } else {
417     chunk.cancel = 0;
418     chunk.data.data_len = len;
419     chunk.data.data_val = (char *) buf;
420   }
421
422   if (send_chunk (&chunk) == -1)
423     return -1;
424
425   if (cancel) return -2;
426   return 0;
427 }
428
429 static int
430 check_for_library_cancellation (void)
431 {
432   fd_set rset;
433   struct timeval tv;
434   int r;
435   char buf[4];
436   uint32_t flag;
437   XDR xdr;
438
439   FD_ZERO (&rset);
440   FD_SET (sock, &rset);
441   tv.tv_sec = 0;
442   tv.tv_usec = 0;
443   r = select (sock+1, &rset, NULL, NULL, &tv);
444   if (r == -1) {
445     perror ("select");
446     return 0;
447   }
448   if (r == 0)
449     return 0;
450
451   /* Read the message from the daemon. */
452   r = xread (sock, buf, sizeof buf);
453   if (r == -1)
454     return 0;
455
456   xdrmem_create (&xdr, buf, sizeof buf, XDR_DECODE);
457   xdr_uint32_t (&xdr, &flag);
458   xdr_destroy (&xdr);
459
460   if (flag != GUESTFS_CANCEL_FLAG) {
461     fprintf (stderr, "check_for_library_cancellation: read 0x%x from library, expected 0x%x\n",
462              flag, GUESTFS_CANCEL_FLAG);
463     return 0;
464   }
465
466   return 1;
467 }
468
469 int
470 send_file_end (int cancel)
471 {
472   guestfs_chunk chunk;
473
474   chunk.cancel = cancel;
475   chunk.data.data_len = 0;
476   chunk.data.data_val = NULL;
477   return send_chunk (&chunk);
478 }
479
480 static int
481 send_chunk (const guestfs_chunk *chunk)
482 {
483   char buf[GUESTFS_MAX_CHUNK_SIZE + 48];
484   char lenbuf[4];
485   XDR xdr;
486   uint32_t len;
487
488   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
489   if (!xdr_guestfs_chunk (&xdr, (guestfs_chunk *) chunk)) {
490     fprintf (stderr, "send_chunk: failed to encode chunk\n");
491     xdr_destroy (&xdr);
492     return -1;
493   }
494
495   len = xdr_getpos (&xdr);
496   xdr_destroy (&xdr);
497
498   xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
499   xdr_uint32_t (&xdr, &len);
500   xdr_destroy (&xdr);
501
502   int err = (xwrite (sock, lenbuf, 4) == 0
503              && xwrite (sock, buf, len) == 0 ? 0 : -1);
504   if (err) {
505     fprintf (stderr, "send_chunk: write failed\n");
506     exit (1);
507   }
508
509   return err;
510 }