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 "../src/guestfs_protocol.h"
33 do_touch (const char *path)
39 fd = open (path, O_WRONLY | O_CREAT | O_NOCTTY, 0666);
43 reply_with_perror ("open: %s", path);
47 r = futimens (fd, NULL);
49 reply_with_perror ("futimens: %s", path);
54 if (close (fd) == -1) {
55 reply_with_perror ("close: %s", path);
63 do_cat (const char *path)
66 int alloc, size, r, max;
70 fd = open (path, O_RDONLY);
74 reply_with_perror ("open: %s", path);
78 /* Read up to GUESTFS_MESSAGE_MAX - <overhead> bytes. If it's
79 * larger than that, we need to return an error instead (for
82 max = GUESTFS_MESSAGE_MAX - 1000;
90 reply_with_error ("%s: file is too large for message buffer",
96 buf2 = realloc (buf, alloc);
98 reply_with_perror ("realloc");
106 r = read (fd, buf + size, alloc - size);
108 reply_with_perror ("read: %s", path);
121 if (close (fd) == -1) {
122 reply_with_perror ("close: %s", path);
127 return buf; /* caller will free */
131 do_read_lines (const char *path)
134 int size = 0, alloc = 0;
141 fp = fopen (path, "r");
145 reply_with_perror ("fopen: %s", path);
149 while ((n = getline (&line, &len, fp)) != -1) {
150 /* Remove either LF or CRLF. */
151 if (n >= 2 && line[n-2] == '\r' && line[n-1] == '\n')
153 else if (n >= 1 && line[n-1] == '\n')
156 if (add_string (&r, &size, &alloc, line) == -1) {
165 if (add_string (&r, &size, &alloc, NULL) == -1) {
170 if (fclose (fp) == EOF) {
171 reply_with_perror ("fclose: %s", path);
180 do_rm (const char *path)
189 reply_with_perror ("%s", path);
197 do_chmod (int mode, const char *path)
202 reply_with_error ("%s: mode is negative", path);
207 r = chmod (path, mode);
211 reply_with_perror ("%s: 0%o", path, mode);
219 do_chown (int owner, int group, const char *path)
224 r = chown (path, owner, group);
228 reply_with_perror ("%s: %d.%d", path, owner, group);
236 do_lchown (int owner, int group, const char *path)
241 r = lchown (path, owner, group);
245 reply_with_perror ("%s: %d.%d", path, owner, group);
253 do_exists (const char *path)
258 r = access (path, F_OK);
265 do_is_file (const char *path)
271 r = lstat (path, &buf);
275 if (errno != ENOENT && errno != ENOTDIR) {
276 reply_with_perror ("stat: %s", path);
280 return 0; /* Not a file. */
283 return S_ISREG (buf.st_mode);
287 do_write_file (const char *path, const char *content, int size)
292 size = strlen (content);
295 fd = open (path, O_WRONLY | O_TRUNC | O_CREAT | O_NOCTTY, 0666);
299 reply_with_perror ("open: %s", path);
303 if (xwrite (fd, content, size) == -1) {
304 reply_with_perror ("write");
309 if (close (fd) == -1) {
310 reply_with_perror ("close: %s", path);
318 do_write (const char *path, const char *content, size_t size)
323 fd = open (path, O_WRONLY | O_TRUNC | O_CREAT | O_NOCTTY, 0666);
327 reply_with_perror ("open: %s", path);
331 if (xwrite (fd, content, size) == -1) {
332 reply_with_perror ("write");
337 if (close (fd) == -1) {
338 reply_with_perror ("close: %s", path);
346 do_read_file (const char *path, size_t *size_r)
353 fd = open (path, O_RDONLY);
357 reply_with_perror ("open: %s", path);
361 if (fstat (fd, &statbuf) == -1) {
362 reply_with_perror ("fstat: %s", path);
367 /* The actual limit on messages is smaller than this. This
368 * check just limits the amount of memory we'll try and allocate
369 * here. If the message is larger than the real limit, that will
370 * be caught later when we try to serialize the message.
372 if (statbuf.st_size >= GUESTFS_MESSAGE_MAX) {
373 reply_with_error ("%s: file is too large for the protocol, use guestfs_download instead", path);
377 r = malloc (statbuf.st_size);
379 reply_with_perror ("malloc");
384 if (xread (fd, r, statbuf.st_size) == -1) {
385 reply_with_perror ("read: %s", path);
391 if (close (fd) == -1) {
392 reply_with_perror ("close: %s", path);
397 /* Mustn't touch *size_r until we are sure that we won't return any
398 * error (RHBZ#589039).
400 *size_r = statbuf.st_size;
405 do_pread (const char *path, int count, int64_t offset, size_t *size_r)
411 /* The actual limit on messages is smaller than this. This check
412 * just limits the amount of memory we'll try and allocate in the
413 * function. If the message is larger than the real limit, that
414 * will be caught later when we try to serialize the message.
416 if (count >= GUESTFS_MESSAGE_MAX) {
417 reply_with_error ("%s: count is too large for the protocol, use smaller reads", path);
422 fd = open (path, O_RDONLY);
426 reply_with_perror ("open: %s", path);
430 buf = malloc (count);
432 reply_with_perror ("malloc");
437 r = pread (fd, buf, count, offset);
439 reply_with_perror ("pread: %s", path);
445 if (close (fd) == -1) {
446 reply_with_perror ("close: %s", path);
452 /* Mustn't touch *size_r until we are sure that we won't return any
453 * error (RHBZ#589039).
460 do_pwrite (const char *path, const char *content, size_t size, int64_t offset)
466 fd = open (path, O_WRONLY);
470 reply_with_perror ("open: %s", path);
474 r = pwrite (fd, content, size, offset);
476 reply_with_perror ("pwrite: %s", path);
481 if (close (fd) == -1) {
482 reply_with_perror ("close: %s", path);
490 /* This runs the 'file' command. */
492 do_file (const char *path)
499 if (STREQLEN (path, "/dev/", 5))
502 buf = sysroot_path (path);
504 reply_with_perror ("malloc");
510 /* file(1) manpage claims "file returns 0 on success, and non-zero on
511 * error", but this is evidently not true. It always returns 0, in
512 * every scenario I can think up. So check the target is readable
515 if (access (buf, R_OK) == -1) {
516 if (freeit) free (buf);
517 reply_with_perror ("access: %s", path);
521 r = command (&out, &err, "file", "-zbsL", buf, NULL);
522 if (freeit) free (buf);
526 reply_with_error ("%s: %s", path, err);
532 /* We need to remove the trailing \n from output of file(1). */
534 if (out[len-1] == '\n')
537 return out; /* caller frees */
542 do_zfile (const char *method, const char *path)
550 if (STREQ (method, "gzip") || STREQ (method, "compress"))
552 else if (STREQ (method, "bzip2"))
555 reply_with_error ("unknown method");
559 if (asprintf_nowarn (&cmd, "%s %R | file -bsL -", zcat, path) == -1) {
560 reply_with_perror ("asprintf");
565 fprintf (stderr, "%s\n", cmd);
567 fp = popen (cmd, "r");
569 reply_with_perror ("%s", cmd);
576 if (fgets (line, sizeof line, fp) == NULL) {
577 reply_with_perror ("fgets");
582 if (fclose (fp) == -1) {
583 reply_with_perror ("fclose");
588 if (len > 0 && line[len-1] == '\n')
591 return strdup (line);
595 do_filesize (const char *path)
601 r = stat (path, &buf); /* follow symlinks */
605 reply_with_perror ("%s", path);