docs: Routine refresh of the documentation for guestfs(3) and guestfish(1).
[libguestfs.git] / daemon / file.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 <string.h>
24 #include <unistd.h>
25 #include <fcntl.h>
26 #include <sys/stat.h>
27
28 #include "../src/guestfs_protocol.h"
29 #include "daemon.h"
30 #include "actions.h"
31
32 int
33 do_touch (const char *path)
34 {
35   int fd;
36   int r;
37
38   CHROOT_IN;
39   fd = open (path, O_WRONLY | O_CREAT | O_NOCTTY, 0666);
40   CHROOT_OUT;
41
42   if (fd == -1) {
43     reply_with_perror ("open: %s", path);
44     return -1;
45   }
46
47   r = futimens (fd, NULL);
48   if (r == -1) {
49     reply_with_perror ("futimens: %s", path);
50     close (fd);
51     return -1;
52   }
53
54   if (close (fd) == -1) {
55     reply_with_perror ("close: %s", path);
56     return -1;
57   }
58
59   return 0;
60 }
61
62 char *
63 do_cat (const char *path)
64 {
65   int fd;
66   int alloc, size, r, max;
67   char *buf, *buf2;
68
69   CHROOT_IN;
70   fd = open (path, O_RDONLY);
71   CHROOT_OUT;
72
73   if (fd == -1) {
74     reply_with_perror ("open: %s", path);
75     return NULL;
76   }
77
78   /* Read up to GUESTFS_MESSAGE_MAX - <overhead> bytes.  If it's
79    * larger than that, we need to return an error instead (for
80    * correctness).
81    */
82   max = GUESTFS_MESSAGE_MAX - 1000;
83   buf = NULL;
84   size = alloc = 0;
85
86   for (;;) {
87     if (size >= alloc) {
88       alloc += 8192;
89       if (alloc > max) {
90         reply_with_error ("%s: file is too large for message buffer",
91                           path);
92         free (buf);
93         close (fd);
94         return NULL;
95       }
96       buf2 = realloc (buf, alloc);
97       if (buf2 == NULL) {
98         reply_with_perror ("realloc");
99         free (buf);
100         close (fd);
101         return NULL;
102       }
103       buf = buf2;
104     }
105
106     r = read (fd, buf + size, alloc - size);
107     if (r == -1) {
108       reply_with_perror ("read: %s", path);
109       free (buf);
110       close (fd);
111       return NULL;
112     }
113     if (r == 0) {
114       buf[size] = '\0';
115       break;
116     }
117     if (r > 0)
118       size += r;
119   }
120
121   if (close (fd) == -1) {
122     reply_with_perror ("close: %s", path);
123     free (buf);
124     return NULL;
125   }
126
127   return buf;                   /* caller will free */
128 }
129
130 char **
131 do_read_lines (const char *path)
132 {
133   char **r = NULL;
134   int size = 0, alloc = 0;
135   FILE *fp;
136   char *line = NULL;
137   size_t len = 0;
138   ssize_t n;
139
140   CHROOT_IN;
141   fp = fopen (path, "r");
142   CHROOT_OUT;
143
144   if (!fp) {
145     reply_with_perror ("fopen: %s", path);
146     return NULL;
147   }
148
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')
152       line[n-2] = '\0';
153     else if (n >= 1 && line[n-1] == '\n')
154       line[n-1] = '\0';
155
156     if (add_string (&r, &size, &alloc, line) == -1) {
157       free (line);
158       fclose (fp);
159       return NULL;
160     }
161   }
162
163   free (line);
164
165   if (add_string (&r, &size, &alloc, NULL) == -1) {
166     fclose (fp);
167     return NULL;
168   }
169
170   if (fclose (fp) == EOF) {
171     reply_with_perror ("fclose: %s", path);
172     free_strings (r);
173     return NULL;
174   }
175
176   return r;
177 }
178
179 int
180 do_rm (const char *path)
181 {
182   int r;
183
184   CHROOT_IN;
185   r = unlink (path);
186   CHROOT_OUT;
187
188   if (r == -1) {
189     reply_with_perror ("%s", path);
190     return -1;
191   }
192
193   return 0;
194 }
195
196 int
197 do_chmod (int mode, const char *path)
198 {
199   int r;
200
201   if (mode < 0) {
202     reply_with_error ("%s: mode is negative", path);
203     return -1;
204   }
205
206   CHROOT_IN;
207   r = chmod (path, mode);
208   CHROOT_OUT;
209
210   if (r == -1) {
211     reply_with_perror ("%s: 0%o", path, mode);
212     return -1;
213   }
214
215   return 0;
216 }
217
218 int
219 do_chown (int owner, int group, const char *path)
220 {
221   int r;
222
223   CHROOT_IN;
224   r = chown (path, owner, group);
225   CHROOT_OUT;
226
227   if (r == -1) {
228     reply_with_perror ("%s: %d.%d", path, owner, group);
229     return -1;
230   }
231
232   return 0;
233 }
234
235 int
236 do_lchown (int owner, int group, const char *path)
237 {
238   int r;
239
240   CHROOT_IN;
241   r = lchown (path, owner, group);
242   CHROOT_OUT;
243
244   if (r == -1) {
245     reply_with_perror ("%s: %d.%d", path, owner, group);
246     return -1;
247   }
248
249   return 0;
250 }
251
252 int
253 do_exists (const char *path)
254 {
255   int r;
256
257   CHROOT_IN;
258   r = access (path, F_OK);
259   CHROOT_OUT;
260
261   return r == 0;
262 }
263
264 int
265 do_is_file (const char *path)
266 {
267   int r;
268   struct stat buf;
269
270   CHROOT_IN;
271   r = lstat (path, &buf);
272   CHROOT_OUT;
273
274   if (r == -1) {
275     if (errno != ENOENT && errno != ENOTDIR) {
276       reply_with_perror ("stat: %s", path);
277       return -1;
278     }
279     else
280       return 0;                 /* Not a file. */
281   }
282
283   return S_ISREG (buf.st_mode);
284 }
285
286 int
287 do_write_file (const char *path, const char *content, int size)
288 {
289   int fd;
290
291   if (size == 0)
292     size = strlen (content);
293
294   CHROOT_IN;
295   fd = open (path, O_WRONLY | O_TRUNC | O_CREAT | O_NOCTTY, 0666);
296   CHROOT_OUT;
297
298   if (fd == -1) {
299     reply_with_perror ("open: %s", path);
300     return -1;
301   }
302
303   if (xwrite (fd, content, size) == -1) {
304     reply_with_perror ("write");
305     close (fd);
306     return -1;
307   }
308
309   if (close (fd) == -1) {
310     reply_with_perror ("close: %s", path);
311     return -1;
312   }
313
314   return 0;
315 }
316
317 char *
318 do_read_file (const char *path, size_t *size_r)
319 {
320   int fd;
321   struct stat statbuf;
322   char *r;
323
324   CHROOT_IN;
325   fd = open (path, O_RDONLY);
326   CHROOT_OUT;
327
328   if (fd == -1) {
329     reply_with_perror ("open: %s", path);
330     return NULL;
331   }
332
333   if (fstat (fd, &statbuf) == -1) {
334     reply_with_perror ("fstat: %s", path);
335     close (fd);
336     return NULL;
337   }
338
339   *size_r = statbuf.st_size;
340   /* The actual limit on messages is smaller than this.  This
341    * check just limits the amount of memory we'll try and allocate
342    * here.  If the message is larger than the real limit, that will
343    * be caught later when we try to serialize the message.
344    */
345   if (*size_r >= GUESTFS_MESSAGE_MAX) {
346     reply_with_error ("%s: file is too large for the protocol, use guestfs_download instead", path);
347     close (fd);
348     return NULL;
349   }
350   r = malloc (*size_r);
351   if (r == NULL) {
352     reply_with_perror ("malloc");
353     close (fd);
354     return NULL;
355   }
356
357   if (xread (fd, r, *size_r) == -1) {
358     reply_with_perror ("read: %s", path);
359     close (fd);
360     free (r);
361     return NULL;
362   }
363
364   if (close (fd) == -1) {
365     reply_with_perror ("close: %s", path);
366     free (r);
367     return NULL;
368   }
369
370   return r;
371 }
372
373 char *
374 do_pread (const char *path, int count, int64_t offset, size_t *size_r)
375 {
376   int fd;
377   ssize_t r;
378   char *buf;
379
380   /* The actual limit on messages is smaller than this.  This check
381    * just limits the amount of memory we'll try and allocate in the
382    * function.  If the message is larger than the real limit, that
383    * will be caught later when we try to serialize the message.
384    */
385   if (count >= GUESTFS_MESSAGE_MAX) {
386     reply_with_error ("%s: count is too large for the protocol, use smaller reads", path);
387     return NULL;
388   }
389
390   CHROOT_IN;
391   fd = open (path, O_RDONLY);
392   CHROOT_OUT;
393
394   if (fd == -1) {
395     reply_with_perror ("open: %s", path);
396     return NULL;
397   }
398
399   buf = malloc (count);
400   if (buf == NULL) {
401     reply_with_perror ("malloc");
402     close (fd);
403     return NULL;
404   }
405
406   r = pread (fd, buf, count, offset);
407   if (r == -1) {
408     reply_with_perror ("pread: %s", path);
409     close (fd);
410     free (buf);
411     return NULL;
412   }
413
414   if (close (fd) == -1) {
415     reply_with_perror ("close: %s", path);
416     close (fd);
417     free (buf);
418     return NULL;
419   }
420
421   *size_r = r;
422   return buf;
423 }
424
425 /* This runs the 'file' command. */
426 char *
427 do_file (const char *path)
428 {
429   char *out, *err;
430   int r, freeit = 0;
431   char *buf;
432   int len;
433
434   if (STREQLEN (path, "/dev/", 5))
435     buf = (char *) path;
436   else {
437     buf = sysroot_path (path);
438     if (!buf) {
439       reply_with_perror ("malloc");
440       return NULL;
441     }
442     freeit = 1;
443   }
444
445   /* file(1) manpage claims "file returns 0 on success, and non-zero on
446    * error", but this is evidently not true.  It always returns 0, in
447    * every scenario I can think up.  So check the target is readable
448    * first.
449    */
450   if (access (buf, R_OK) == -1) {
451     if (freeit) free (buf);
452     reply_with_perror ("access: %s", path);
453     return NULL;
454   }
455
456   r = command (&out, &err, "file", "-zbsL", buf, NULL);
457   if (freeit) free (buf);
458
459   if (r == -1) {
460     free (out);
461     reply_with_error ("%s: %s", path, err);
462     free (err);
463     return NULL;
464   }
465   free (err);
466
467   /* We need to remove the trailing \n from output of file(1). */
468   len = strlen (out);
469   if (out[len-1] == '\n')
470     out[len-1] = '\0';
471
472   return out;                   /* caller frees */
473 }
474
475 /* zcat | file */
476 char *
477 do_zfile (const char *method, const char *path)
478 {
479   int len;
480   const char *zcat;
481   char *cmd;
482   FILE *fp;
483   char line[256];
484
485   if (STREQ (method, "gzip") || STREQ (method, "compress"))
486     zcat = "zcat";
487   else if (STREQ (method, "bzip2"))
488     zcat = "bzcat";
489   else {
490     reply_with_error ("unknown method");
491     return NULL;
492   }
493
494   if (asprintf_nowarn (&cmd, "%s %R | file -bsL -", zcat, path) == -1) {
495     reply_with_perror ("asprintf");
496     return NULL;
497   }
498
499   if (verbose)
500     fprintf (stderr, "%s\n", cmd);
501
502   fp = popen (cmd, "r");
503   if (fp == NULL) {
504     reply_with_perror ("%s", cmd);
505     free (cmd);
506     return NULL;
507   }
508
509   free (cmd);
510
511   if (fgets (line, sizeof line, fp) == NULL) {
512     reply_with_perror ("fgets");
513     fclose (fp);
514     return NULL;
515   }
516
517   if (fclose (fp) == -1) {
518     reply_with_perror ("fclose");
519     return NULL;
520   }
521
522   len = strlen (line);
523   if (len > 0 && line[len-1] == '\n')
524     line[len-1] = '\0';
525
526   return strdup (line);
527 }
528
529 int64_t
530 do_filesize (const char *path)
531 {
532   int r;
533   struct stat buf;
534
535   CHROOT_IN;
536   r = stat (path, &buf);        /* follow symlinks */
537   CHROOT_OUT;
538
539   if (r == -1) {
540     reply_with_perror ("%s", path);
541     return -1;
542   }
543
544   return buf.st_size;
545 }