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 <inttypes.h>
  26 #include <unistd.h>
  27 #include <errno.h>
  28 #include <sys/param.h>          /* defines MIN */
  29 #include <sys/select.h>
  30 #include <sys/time.h>
  31 #include <rpc/types.h>
  32 #include <rpc/xdr.h>
  33
  34 #ifdef HAVE_WINDOWS_H
  35 #include <windows.h>
  36 #endif
  37
  38 #include "c-ctype.h"
  39 #include "ignore-value.h"
  40
  41 #include "daemon.h"
  42 #include "guestfs_protocol.h"
  43 #include "errnostring.h"
  44
  45 /* The message currently being processed. */
  46 int proc_nr;
  47 int serial;
  48
  49 /* Hint for implementing progress messages for uploaded/incoming data.
  50  * The caller sets this to a value > 0 if it knows or can estimate how
  51  * much data will be sent (this is not always known, eg. for uploads
  52  * coming from a pipe).  If this is known then we can emit progress
  53  * messages as we write the data.
  54  */
  55 uint64_t progress_hint;
  56
  57 /* Optional arguments bitmask.  Caller sets this to indicate which
  58  * optional arguments in the guestfs_<foo>_args structure are
  59  * meaningful.  Optional arguments not covered by the bitmask are set
  60  * to arbitrary values and the daemon should ignore them.  If the
  61  * bitmask has bits set that the daemon doesn't understand, then the
  62  * whole call is rejected early in processing.
  63  */
  64 uint64_t optargs_bitmask;
  65
  66 /* Time at which we received the current request. */
  67 static struct timeval start_t;
  68
  69 /* Time at which the last progress notification was sent. */
  70 static struct timeval last_progress_t;
  71
  72 /* Counts the number of progress notifications sent during this call. */
  73 static int count_progress;
  74
  75 /* The daemon communications socket. */
  76 static int sock;
  77
  78 void
  79 main_loop (int _sock)
  80 {
  81   XDR xdr;
  82   char *buf;
  83   char lenbuf[4];
  84   uint32_t len;
  85   struct guestfs_message_header hdr;
  86
  87   sock = _sock;
  88
  89   for (;;) {
  90     /* Most common errors are leaked memory and leaked file descriptors,
  91      * so run this between each command:
  92      */
  93     if (verbose && 0)
  94       ignore_value (system ("ls -l /proc/self/fd"));
  95
  96     /* Read the length word. */
  97     if (xread (sock, lenbuf, 4) == -1)
  98       exit (EXIT_FAILURE);
  99
 100     xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
 101     xdr_u_int (&xdr, &len);
 102     xdr_destroy (&xdr);
 103
 104     if (len > GUESTFS_MESSAGE_MAX) {
 105       fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
 106                len);
 107       exit (EXIT_FAILURE);
 108     }
 109
 110     buf = malloc (len);
 111     if (!buf) {
 112       reply_with_perror ("malloc");
 113       continue;
 114     }
 115
 116     if (xread (sock, buf, len) == -1)
 117       exit (EXIT_FAILURE);
 118
 119 #ifdef ENABLE_PACKET_DUMP
 120     if (verbose) {
 121       size_t i, j;
 122
 123       for (i = 0; i < len; i += 16) {
 124         printf ("%04zx: ", i);
 125         for (j = i; j < MIN (i+16, len); ++j)
 126           printf ("%02x ", (unsigned char) buf[j]);
 127         for (; j < i+16; ++j)
 128           printf ("   ");
 129         printf ("|");
 130         for (j = i; j < MIN (i+16, len); ++j)
 131           if (c_isprint (buf[j]))
 132             printf ("%c", buf[j]);
 133           else
 134             printf (".");
 135         for (; j < i+16; ++j)
 136           printf (" ");
 137         printf ("|\n");
 138       }
 139     }
 140 #endif
 141
 142     gettimeofday (&start_t, NULL);
 143     last_progress_t = start_t;
 144     count_progress = 0;
 145
 146     /* Decode the message header. */
 147     xdrmem_create (&xdr, buf, len, XDR_DECODE);
 148     if (!xdr_guestfs_message_header (&xdr, &hdr)) {
 149       fprintf (stderr, "guestfsd: could not decode message header\n");
 150       exit (EXIT_FAILURE);
 151     }
 152
 153     /* Check the version etc. */
 154     if (hdr.prog != GUESTFS_PROGRAM) {
 155       reply_with_error ("wrong program (%d)", hdr.prog);
 156       goto cont;
 157     }
 158     if (hdr.vers != GUESTFS_PROTOCOL_VERSION) {
 159       reply_with_error ("wrong protocol version (%d)", hdr.vers);
 160       goto cont;
 161     }
 162     if (hdr.direction != GUESTFS_DIRECTION_CALL) {
 163       reply_with_error ("unexpected message direction (%d)", hdr.direction);
 164       goto cont;
 165     }
 166     if (hdr.status != GUESTFS_STATUS_OK) {
 167       reply_with_error ("unexpected message status (%d)", hdr.status);
 168       goto cont;
 169     }
 170
 171     proc_nr = hdr.proc;
 172     serial = hdr.serial;
 173     progress_hint = hdr.progress_hint;
 174     optargs_bitmask = hdr.optargs_bitmask;
 175
 176     /* Clear errors before we call the stub functions.  This is just
 177      * to ensure that we can accurately report errors in cases where
 178      * error handling paths don't set errno correctly.
 179      */
 180     errno = 0;
 181 #ifdef WIN32
 182     SetLastError (0);
 183     WSASetLastError (0);
 184 #endif
 185
 186     /* Now start to process this message. */
 187     dispatch_incoming_message (&xdr);
 188     /* Note that dispatch_incoming_message will also send a reply. */
 189
 190     /* In verbose mode, display the time taken to run each command. */
 191     if (verbose) {
 192       struct timeval end_t;
 193       gettimeofday (&end_t, NULL);
 194
 195       int64_t start_us, end_us, elapsed_us;
 196       start_us = (int64_t) start_t.tv_sec * 1000000 + start_t.tv_usec;
 197       end_us = (int64_t) end_t.tv_sec * 1000000 + end_t.tv_usec;
 198       elapsed_us = end_us - start_us;
 199
 200       fprintf (stderr, "proc %d (%s) took %d.%02d seconds\n",
 201                proc_nr,
 202                proc_nr >= 0 && proc_nr < GUESTFS_PROC_NR_PROCS
 203                ? function_names[proc_nr] : "UNKNOWN PROCEDURE",
 204                (int) (elapsed_us / 1000000),
 205                (int) ((elapsed_us / 10000) % 100));
 206     }
 207
 208   cont:
 209     xdr_destroy (&xdr);
 210     free (buf);
 211   }
 212 }
 213
 214 static void send_error (int errnum, const char *msg);
 215
 216 void
 217 reply_with_error (const char *fs, ...)
 218 {
 219   char err[GUESTFS_ERROR_LEN];
 220   va_list args;
 221
 222   va_start (args, fs);
 223   vsnprintf (err, sizeof err, fs, args);
 224   va_end (args);
 225
 226   send_error (0, err);
 227 }
 228
 229 void
 230 reply_with_perror_errno (int err, const char *fs, ...)
 231 {
 232   char buf1[GUESTFS_ERROR_LEN];
 233   char buf2[GUESTFS_ERROR_LEN];
 234   va_list args;
 235
 236   va_start (args, fs);
 237   vsnprintf (buf1, sizeof buf1, fs, args);
 238   va_end (args);
 239
 240   snprintf (buf2, sizeof buf2, "%s: %s", buf1, strerror (err));
 241
 242   send_error (err, buf2);
 243 }
 244
 245 static void
 246 send_error (int errnum, const char *msg)
 247 {
 248   XDR xdr;
 249   char buf[GUESTFS_ERROR_LEN + 200];
 250   char lenbuf[4];
 251   struct guestfs_message_header hdr;
 252   struct guestfs_message_error err;
 253   unsigned len;
 254
 255   fprintf (stderr, "guestfsd: error: %s\n", msg);
 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_ERROR;
 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 error message header\n");
 268     exit (EXIT_FAILURE);
 269   }
 270
 271   /* These strings are not going to be freed.  We just cast them
 272    * to (char *) because they are defined that way in the XDR structs.
 273    */
 274   err.errno_string =
 275     (char *) (errnum > 0 ? guestfs___errno_to_string (errnum) : "");
 276   err.error_message = (char *) msg;
 277
 278   if (!xdr_guestfs_message_error (&xdr, &err)) {
 279     fprintf (stderr, "guestfsd: failed to encode error message body\n");
 280     exit (EXIT_FAILURE);
 281   }
 282
 283   len = xdr_getpos (&xdr);
 284   xdr_destroy (&xdr);
 285
 286   xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
 287   xdr_u_int (&xdr, &len);
 288   xdr_destroy (&xdr);
 289
 290   if (xwrite (sock, lenbuf, 4) == -1) {
 291     fprintf (stderr, "xwrite failed\n");
 292     exit (EXIT_FAILURE);
 293   }
 294   if (xwrite (sock, buf, len) == -1) {
 295     fprintf (stderr, "xwrite failed\n");
 296     exit (EXIT_FAILURE);
 297   }
 298 }
 299
 300 void
 301 reply (xdrproc_t xdrp, char *ret)
 302 {
 303   XDR xdr;
 304   char buf[GUESTFS_MESSAGE_MAX];
 305   char lenbuf[4];
 306   struct guestfs_message_header hdr;
 307   unsigned len;
 308
 309   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
 310
 311   hdr.prog = GUESTFS_PROGRAM;
 312   hdr.vers = GUESTFS_PROTOCOL_VERSION;
 313   hdr.direction = GUESTFS_DIRECTION_REPLY;
 314   hdr.status = GUESTFS_STATUS_OK;
 315   hdr.proc = proc_nr;
 316   hdr.serial = serial;
 317
 318   if (!xdr_guestfs_message_header (&xdr, &hdr)) {
 319     fprintf (stderr, "guestfsd: failed to encode reply header\n");
 320     exit (EXIT_FAILURE);
 321   }
 322
 323   if (xdrp) {
 324     /* This can fail if the reply body is too large, for example
 325      * if it exceeds the maximum message size.  In that case
 326      * we want to return an error message instead. (RHBZ#509597).
 327      */
 328     if (!(*xdrp) (&xdr, ret)) {
 329       reply_with_error ("guestfsd: failed to encode reply body\n(maybe the reply exceeds the maximum message size in the protocol?)");
 330       xdr_destroy (&xdr);
 331       return;
 332     }
 333   }
 334
 335   len = xdr_getpos (&xdr);
 336   xdr_destroy (&xdr);
 337
 338   xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
 339   xdr_u_int (&xdr, &len);
 340   xdr_destroy (&xdr);
 341
 342   if (xwrite (sock, lenbuf, 4) == -1) {
 343     fprintf (stderr, "xwrite failed\n");
 344     exit (EXIT_FAILURE);
 345   }
 346   if (xwrite (sock, buf, len) == -1) {
 347     fprintf (stderr, "xwrite failed\n");
 348     exit (EXIT_FAILURE);
 349   }
 350 }
 351
 352 /* Receive file chunks, repeatedly calling 'cb'. */
 353 int
 354 receive_file (receive_cb cb, void *opaque)
 355 {
 356   guestfs_chunk chunk;
 357   char lenbuf[4];
 358   char *buf;
 359   XDR xdr;
 360   int r;
 361   uint32_t len;
 362
 363   for (;;) {
 364     if (verbose)
 365       fprintf (stderr, "receive_file: reading length word\n");
 366
 367     /* Read the length word. */
 368     if (xread (sock, lenbuf, 4) == -1)
 369       exit (EXIT_FAILURE);
 370
 371     xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
 372     xdr_u_int (&xdr, &len);
 373     xdr_destroy (&xdr);
 374
 375     if (len == GUESTFS_CANCEL_FLAG)
 376       continue;                 /* Just ignore it. */
 377
 378     if (len > GUESTFS_MESSAGE_MAX) {
 379       fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
 380                len);
 381       exit (EXIT_FAILURE);
 382     }
 383
 384     buf = malloc (len);
 385     if (!buf) {
 386       perror ("malloc");
 387       return -1;
 388     }
 389
 390     if (xread (sock, buf, len) == -1)
 391       exit (EXIT_FAILURE);
 392
 393     xdrmem_create (&xdr, buf, len, XDR_DECODE);
 394     memset (&chunk, 0, sizeof chunk);
 395     if (!xdr_guestfs_chunk (&xdr, &chunk)) {
 396       xdr_destroy (&xdr);
 397       free (buf);
 398       return -1;
 399     }
 400     xdr_destroy (&xdr);
 401     free (buf);
 402
 403     if (verbose)
 404       fprintf (stderr, "receive_file: got chunk: cancel = %d, len = %d, buf = %p\n",
 405                chunk.cancel, chunk.data.data_len, chunk.data.data_val);
 406
 407     if (chunk.cancel) {
 408       if (verbose)
 409         fprintf (stderr, "receive_file: received cancellation from library\n");
 410       xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
 411       return -2;
 412     }
 413     if (chunk.data.data_len == 0) {
 414       if (verbose)
 415         fprintf (stderr, "receive_file: end of file, leaving function\n");
 416       xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
 417       return 0;                 /* end of file */
 418     }
 419
 420     /* Note that the callback can generate progress messages. */
 421     if (cb)
 422       r = cb (opaque, chunk.data.data_val, chunk.data.data_len);
 423     else
 424       r = 0;
 425
 426     xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
 427     if (r == -1) {              /* write error */
 428       if (verbose)
 429         fprintf (stderr, "receive_file: write error\n");
 430       return -1;
 431     }
 432   }
 433 }
 434
 435 /* Send a cancellation flag back to the library. */
 436 int
 437 cancel_receive (void)
 438 {
 439   XDR xdr;
 440   char fbuf[4];
 441   uint32_t flag = GUESTFS_CANCEL_FLAG;
 442
 443   xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE);
 444   xdr_u_int (&xdr, &flag);
 445   xdr_destroy (&xdr);
 446
 447   if (xwrite (sock, fbuf, sizeof fbuf) == -1) {
 448     perror ("write to socket");
 449     return -1;
 450   }
 451
 452   /* Keep receiving chunks and discarding, until library sees cancel. */
 453   return receive_file (NULL, NULL);
 454 }
 455
 456 static int check_for_library_cancellation (void);
 457 static int send_chunk (const guestfs_chunk *);
 458
 459 /* Also check if the library sends us a cancellation message. */
 460 int
 461 send_file_write (const void *buf, int len)
 462 {
 463   guestfs_chunk chunk;
 464   int cancel;
 465
 466   if (len > GUESTFS_MAX_CHUNK_SIZE) {
 467     fprintf (stderr, "send_file_write: len (%d) > GUESTFS_MAX_CHUNK_SIZE (%d)\n",
 468              len, GUESTFS_MAX_CHUNK_SIZE);
 469     return -1;
 470   }
 471
 472   cancel = check_for_library_cancellation ();
 473
 474   if (cancel) {
 475     chunk.cancel = 1;
 476     chunk.data.data_len = 0;
 477     chunk.data.data_val = NULL;
 478   } else {
 479     chunk.cancel = 0;
 480     chunk.data.data_len = len;
 481     chunk.data.data_val = (char *) buf;
 482   }
 483
 484   if (send_chunk (&chunk) == -1)
 485     return -1;
 486
 487   if (cancel) return -2;
 488   return 0;
 489 }
 490
 491 static int
 492 check_for_library_cancellation (void)
 493 {
 494   fd_set rset;
 495   struct timeval tv;
 496   int r;
 497   char buf[4];
 498   uint32_t flag;
 499   XDR xdr;
 500
 501   FD_ZERO (&rset);
 502   FD_SET (sock, &rset);
 503   tv.tv_sec = 0;
 504   tv.tv_usec = 0;
 505   r = select (sock+1, &rset, NULL, NULL, &tv);
 506   if (r == -1) {
 507     perror ("select");
 508     return 0;
 509   }
 510   if (r == 0)
 511     return 0;
 512
 513   /* Read the message from the daemon. */
 514   r = xread (sock, buf, sizeof buf);
 515   if (r == -1)
 516     return 0;
 517
 518   xdrmem_create (&xdr, buf, sizeof buf, XDR_DECODE);
 519   xdr_u_int (&xdr, &flag);
 520   xdr_destroy (&xdr);
 521
 522   if (flag != GUESTFS_CANCEL_FLAG) {
 523     fprintf (stderr, "check_for_library_cancellation: read 0x%x from library, expected 0x%x\n",
 524              flag, GUESTFS_CANCEL_FLAG);
 525     return 0;
 526   }
 527
 528   return 1;
 529 }
 530
 531 int
 532 send_file_end (int cancel)
 533 {
 534   guestfs_chunk chunk;
 535
 536   chunk.cancel = cancel;
 537   chunk.data.data_len = 0;
 538   chunk.data.data_val = NULL;
 539   return send_chunk (&chunk);
 540 }
 541
 542 static int
 543 send_chunk (const guestfs_chunk *chunk)
 544 {
 545   char buf[GUESTFS_MAX_CHUNK_SIZE + 48];
 546   char lenbuf[4];
 547   XDR xdr;
 548   uint32_t len;
 549
 550   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
 551   if (!xdr_guestfs_chunk (&xdr, (guestfs_chunk *) chunk)) {
 552     fprintf (stderr, "send_chunk: failed to encode chunk\n");
 553     xdr_destroy (&xdr);
 554     return -1;
 555   }
 556
 557   len = xdr_getpos (&xdr);
 558   xdr_destroy (&xdr);
 559
 560   xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
 561   xdr_u_int (&xdr, &len);
 562   xdr_destroy (&xdr);
 563
 564   int err = (xwrite (sock, lenbuf, 4) == 0
 565              && xwrite (sock, buf, len) == 0 ? 0 : -1);
 566   if (err) {
 567     fprintf (stderr, "send_chunk: write failed\n");
 568     exit (EXIT_FAILURE);
 569   }
 570
 571   return err;
 572 }
 573
 574 /* Initial delay before sending notification messages, and
 575  * the period at which we send them thereafter.  These times
 576  * are in microseconds.
 577  */
 578 #define NOTIFICATION_INITIAL_DELAY 2000000
 579 #define NOTIFICATION_PERIOD         333333
 580
 581 void
 582 notify_progress (uint64_t position, uint64_t total)
 583 {
 584   struct timeval now_t;
 585   gettimeofday (&now_t, NULL);
 586
 587   /* Always send a notification at 100%.  This simplifies callers by
 588    * allowing them to 'finish' the progress bar at 100% without
 589    * needing special code.
 590    */
 591   if (count_progress > 0 && position == total)
 592     goto send;
 593
 594   /* Calculate time in microseconds since the last progress message
 595    * was sent out (or since the start of the call).
 596    */
 597   int64_t last_us, now_us, elapsed_us;
 598   last_us =
 599     (int64_t) last_progress_t.tv_sec * 1000000 + last_progress_t.tv_usec;
 600   now_us = (int64_t) now_t.tv_sec * 1000000 + now_t.tv_usec;
 601   elapsed_us = now_us - last_us;
 602
 603   /* Rate limit. */
 604   if ((count_progress == 0 && elapsed_us < NOTIFICATION_INITIAL_DELAY) ||
 605       (count_progress > 0 && elapsed_us < NOTIFICATION_PERIOD))
 606     return;
 607
 608  send:
 609   /* We're going to send a message now ... */
 610   count_progress++;
 611   last_progress_t = now_t;
 612
 613   /* Send the header word. */
 614   XDR xdr;
 615   char buf[128];
 616   uint32_t i = GUESTFS_PROGRESS_FLAG;
 617   size_t len;
 618   xdrmem_create (&xdr, buf, 4, XDR_ENCODE);
 619   xdr_u_int (&xdr, &i);
 620   xdr_destroy (&xdr);
 621
 622   if (xwrite (sock, buf, 4) == -1) {
 623     fprintf (stderr, "xwrite failed\n");
 624     exit (EXIT_FAILURE);
 625   }
 626
 627   guestfs_progress message = {
 628     .proc = proc_nr,
 629     .serial = serial,
 630     .position = position,
 631     .total = total,
 632   };
 633
 634   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
 635   if (!xdr_guestfs_progress (&xdr, &message)) {
 636     fprintf (stderr, "xdr_guestfs_progress: failed to encode message\n");
 637     xdr_destroy (&xdr);
 638     return;
 639   }
 640   len = xdr_getpos (&xdr);
 641   xdr_destroy (&xdr);
 642
 643   if (xwrite (sock, buf, len) == -1) {
 644     fprintf (stderr, "xwrite failed\n");
 645     exit (EXIT_FAILURE);
 646   }
 647 }