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);
48 r = futimens (fd, NULL);
50 r = futimes (fd, NULL);
53 reply_with_perror ("futimens: %s", path);
58 if (close (fd) == -1) {
59 reply_with_perror ("close: %s", path);
67 do_cat (const char *path)
70 int alloc, size, r, max;
74 fd = open (path, O_RDONLY);
78 reply_with_perror ("open: %s", path);
82 /* Read up to GUESTFS_MESSAGE_MAX - <overhead> bytes. If it's
83 * larger than that, we need to return an error instead (for
86 max = GUESTFS_MESSAGE_MAX - 1000;
94 reply_with_error ("cat: %s: file is too large for message buffer",
100 buf2 = realloc (buf, alloc);
102 reply_with_perror ("realloc");
110 r = read (fd, buf + size, alloc - size);
112 reply_with_perror ("read: %s", path);
125 if (close (fd) == -1) {
126 reply_with_perror ("close: %s", path);
131 return buf; /* caller will free */
135 do_read_lines (const char *path)
138 int size = 0, alloc = 0;
145 fp = fopen (path, "r");
149 reply_with_perror ("fopen: %s", path);
153 while ((n = getline (&line, &len, fp)) != -1) {
154 /* Remove either LF or CRLF. */
155 if (n >= 2 && line[n-2] == '\r' && line[n-1] == '\n')
157 else if (n >= 1 && line[n-1] == '\n')
160 if (add_string (&r, &size, &alloc, line) == -1) {
169 if (add_string (&r, &size, &alloc, NULL) == -1) {
174 if (fclose (fp) == EOF) {
175 reply_with_perror ("fclose: %s", path);
184 do_rm (const char *path)
193 reply_with_perror ("unlink: %s", path);
201 do_chmod (int mode, const char *path)
206 r = chmod (path, mode);
210 reply_with_perror ("chmod: %s: 0%o", path, mode);
218 do_chown (int owner, int group, const char *path)
223 r = chown (path, owner, group);
227 reply_with_perror ("chown: %s: %d.%d", path, owner, group);
235 do_exists (const char *path)
240 r = access (path, F_OK);
247 do_is_file (const char *path)
253 r = lstat (path, &buf);
257 if (errno != ENOENT && errno != ENOTDIR) {
258 reply_with_perror ("stat: %s", path);
262 return 0; /* Not a file. */
265 return S_ISREG (buf.st_mode);
269 do_write_file (const char *path, const char *content, int size)
274 size = strlen (content);
277 fd = open (path, O_WRONLY | O_TRUNC | O_CREAT | O_NOCTTY, 0666);
281 reply_with_perror ("open: %s", path);
285 if (xwrite (fd, content, size) == -1) {
286 reply_with_perror ("write");
291 if (close (fd) == -1) {
292 reply_with_perror ("close: %s", path);
300 do_read_file (const char *path, size_t *size_r)
307 fd = open (path, O_RDONLY);
311 reply_with_perror ("open: %s", path);
315 if (fstat (fd, &statbuf) == -1) {
316 reply_with_perror ("fstat: %s", path);
321 *size_r = statbuf.st_size;
322 /* The actual limit on messages is smaller than this. This
323 * check just limits the amount of memory we'll try and allocate
324 * here. If the message is larger than the real limit, that will
325 * be caught later when we try to serialize the message.
327 if (*size_r >= GUESTFS_MESSAGE_MAX) {
328 reply_with_error ("read_file: %s: file is too large for the protocol, use guestfs_download instead", path);
332 r = malloc (*size_r);
334 reply_with_perror ("malloc");
339 if (xread (fd, r, *size_r) == -1) {
340 reply_with_perror ("read: %s", path);
346 if (close (fd) == -1) {
347 reply_with_perror ("close: %s", path);
355 /* This runs the 'file' command. */
357 do_file (const char *path)
364 if (strncmp (path, "/dev/", 5) == 0)
367 buf = sysroot_path (path);
369 reply_with_perror ("malloc");
375 /* file(1) manpage claims "file returns 0 on success, and non-zero on
376 * error", but this is evidently not true. It always returns 0, in
377 * every scenario I can think up. So check the target is readable
380 if (access (buf, R_OK) == -1) {
381 if (freeit) free (buf);
382 reply_with_perror ("access: %s", path);
386 r = command (&out, &err, "file", "-zbsL", buf, NULL);
387 if (freeit) free (buf);
391 reply_with_error ("file: %s: %s", path, err);
397 /* We need to remove the trailing \n from output of file(1). */
399 if (out[len-1] == '\n')
402 return out; /* caller frees */
407 do_zfile (const char *method, const char *path)
415 if (strcmp (method, "gzip") == 0 || strcmp (method, "compress") == 0)
417 else if (strcmp (method, "bzip2") == 0)
420 reply_with_error ("zfile: unknown method");
424 if (asprintf_nowarn (&cmd, "%s %R | file -bsL -", zcat, path) == -1) {
425 reply_with_perror ("asprintf");
430 fprintf (stderr, "%s\n", cmd);
432 fp = popen (cmd, "r");
434 reply_with_perror ("%s", cmd);
441 if (fgets (line, sizeof line, fp) == NULL) {
442 reply_with_perror ("zfile: fgets");
447 if (fclose (fp) == -1) {
448 reply_with_perror ("zfile: fclose");
453 if (len > 0 && line[len-1] == '\n')
456 return strdup (line);