enforce sane readdir usage
[libvirt:libvirt.git] / src / util / virfile.c
1 /*
2  * virfile.c: safer file handling
3  *
4  * Copyright (C) 2010-2014 Red Hat, Inc.
5  * Copyright (C) 2010 IBM Corporation
6  * Copyright (C) 2010 Stefan Berger
7  * Copyright (C) 2010 Eric Blake
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library.  If not, see
21  * <http://www.gnu.org/licenses/>.
22  *
23  */
24
25 #include <config.h>
26 #include "internal.h"
27
28 #include <passfd.h>
29 #include <fcntl.h>
30 #include <pty.h>
31 #include <sys/stat.h>
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <sys/wait.h>
35 #include <unistd.h>
36 #include <dirent.h>
37 #include <dirname.h>
38 #if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
39 # include <mntent.h>
40 #endif
41 #include <stdlib.h>
42 #if HAVE_MMAP
43 # include <sys/mman.h>
44 #endif
45
46 #ifdef __linux__
47 # if HAVE_LINUX_MAGIC_H
48 #  include <linux/magic.h>
49 # endif
50 # include <sys/statfs.h>
51 #endif
52
53 #if defined(__linux__) && HAVE_DECL_LO_FLAGS_AUTOCLEAR
54 # include <linux/loop.h>
55 # include <sys/ioctl.h>
56 #endif
57
58 #include "configmake.h"
59 #include "viralloc.h"
60 #include "vircommand.h"
61 #include "virerror.h"
62 #include "virfile.h"
63 #include "virlog.h"
64 #include "virprocess.h"
65 #include "virstring.h"
66 #include "virstoragefile.h"
67 #include "virutil.h"
68
69 #include "c-ctype.h"
70
71 #define VIR_FROM_THIS VIR_FROM_NONE
72
73 VIR_LOG_INIT("util.file");
74
75 int virFileClose(int *fdptr, virFileCloseFlags flags)
76 {
77     int saved_errno = 0;
78     int rc = 0;
79
80     if (*fdptr < 0)
81         return 0;
82
83     if (flags & VIR_FILE_CLOSE_PRESERVE_ERRNO)
84         saved_errno = errno;
85
86     rc = close(*fdptr);
87
88     if (!(flags & VIR_FILE_CLOSE_DONT_LOG)) {
89         if (rc < 0) {
90             if (errno == EBADF) {
91                 if (!(flags & VIR_FILE_CLOSE_IGNORE_EBADF))
92                     VIR_WARN("Tried to close invalid fd %d", *fdptr);
93             } else {
94                 char ebuf[1024] ATTRIBUTE_UNUSED;
95                 VIR_DEBUG("Failed to close fd %d: %s",
96                           *fdptr, virStrerror(errno, ebuf, sizeof(ebuf)));
97             }
98         } else {
99             VIR_DEBUG("Closed fd %d", *fdptr);
100         }
101     }
102     *fdptr = -1;
103
104     if (flags & VIR_FILE_CLOSE_PRESERVE_ERRNO)
105         errno = saved_errno;
106
107     return rc;
108 }
109
110
111 int virFileFclose(FILE **file, bool preserve_errno)
112 {
113     int saved_errno = 0;
114     int rc = 0;
115
116     if (*file) {
117         if (preserve_errno)
118             saved_errno = errno;
119         rc = fclose(*file);
120         *file = NULL;
121         if (preserve_errno)
122             errno = saved_errno;
123     }
124
125     return rc;
126 }
127
128
129 FILE *virFileFdopen(int *fdptr, const char *mode)
130 {
131     FILE *file = NULL;
132
133     if (*fdptr >= 0) {
134         file = fdopen(*fdptr, mode);
135         if (file)
136             *fdptr = -1;
137     } else {
138         errno = EBADF;
139     }
140
141     return file;
142 }
143
144
145 /**
146  * virFileDirectFdFlag:
147  *
148  * Returns 0 if the kernel can avoid file system cache pollution
149  * without any additional flags, O_DIRECT if the original fd must be
150  * opened in direct mode, or -1 if there is no support for bypassing
151  * the file system cache.
152  */
153 int
154 virFileDirectFdFlag(void)
155 {
156     /* XXX For now, Linux posix_fadvise is not powerful enough to
157      * avoid O_DIRECT.  */
158     return O_DIRECT ? O_DIRECT : -1;
159 }
160
161 /* Opaque type for managing a wrapper around a fd.  For now,
162  * read-write is not supported, just a single direction.  */
163 struct _virFileWrapperFd {
164     virCommandPtr cmd; /* Child iohelper process to do the I/O.  */
165     char *err_msg; /* stderr of @cmd */
166 };
167
168 #ifndef WIN32
169 /**
170  * virFileWrapperFdNew:
171  * @fd: pointer to fd to wrap
172  * @name: name of fd, for diagnostics
173  * @flags: bitwise-OR of virFileWrapperFdFlags
174  *
175  * Update @fd so that it meets parameters requested by @flags.
176  *
177  * If VIR_FILE_WRAPPER_BYPASS_CACHE bit is set in @flags, @fd will be updated
178  * in a way that all I/O to that file will bypass the system cache.  The
179  * original fd must have been created with virFileDirectFdFlag() among the
180  * flags to open().
181  *
182  * If VIR_FILE_WRAPPER_NON_BLOCKING bit is set in @flags, @fd will be updated
183  * to ensure it properly supports non-blocking I/O, i.e., it will report
184  * EAGAIN.
185  *
186  * This must be called after open() and optional fchown() or fchmod(), but
187  * before any seek or I/O, and only on seekable fd.  The file must be O_RDONLY
188  * (to read the entire existing file) or O_WRONLY (to write to an empty file).
189  * In some cases, @fd is changed to a non-seekable pipe; in this case, the
190  * caller must not do anything further with the original fd.
191  *
192  * On success, the new wrapper object is returned, which must be later
193  * freed with virFileWrapperFdFree().  On failure, @fd is unchanged, an
194  * error message is output, and NULL is returned.
195  */
196 virFileWrapperFdPtr
197 virFileWrapperFdNew(int *fd, const char *name, unsigned int flags)
198 {
199     virFileWrapperFdPtr ret = NULL;
200     bool output = false;
201     int pipefd[2] = { -1, -1 };
202     int mode = -1;
203     char *iohelper_path = NULL;
204
205     if (!flags) {
206         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
207                        _("invalid use with no flags"));
208         return NULL;
209     }
210
211     /* XXX support posix_fadvise rather than O_DIRECT, if the kernel support
212      * for that is decent enough. In that case, we will also need to
213      * explicitly support VIR_FILE_WRAPPER_NON_BLOCKING since
214      * VIR_FILE_WRAPPER_BYPASS_CACHE alone will no longer require spawning
215      * iohelper.
216      */
217
218     if ((flags & VIR_FILE_WRAPPER_BYPASS_CACHE) && !O_DIRECT) {
219         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
220                        _("O_DIRECT unsupported on this platform"));
221         return NULL;
222     }
223
224     if (VIR_ALLOC(ret) < 0)
225         return NULL;
226
227     mode = fcntl(*fd, F_GETFL);
228
229     if (mode < 0) {
230         virReportError(VIR_ERR_INTERNAL_ERROR, _("invalid fd %d for %s"),
231                        *fd, name);
232         goto error;
233     } else if ((mode & O_ACCMODE) == O_WRONLY) {
234         output = true;
235     } else if ((mode & O_ACCMODE) != O_RDONLY) {
236         virReportError(VIR_ERR_INTERNAL_ERROR, _("unexpected mode %x for %s"),
237                        mode & O_ACCMODE, name);
238         goto error;
239     }
240
241     if (pipe2(pipefd, O_CLOEXEC) < 0) {
242         virReportError(VIR_ERR_INTERNAL_ERROR,
243                        _("unable to create pipe for %s"), name);
244         goto error;
245     }
246
247     if (!(iohelper_path = virFileFindResource("libvirt_iohelper",
248                                               "src",
249                                               LIBEXECDIR)))
250         goto error;
251
252     ret->cmd = virCommandNewArgList(iohelper_path, name, "0", NULL);
253
254     VIR_FREE(iohelper_path);
255
256     if (output) {
257         virCommandSetInputFD(ret->cmd, pipefd[0]);
258         virCommandSetOutputFD(ret->cmd, fd);
259         virCommandAddArg(ret->cmd, "1");
260     } else {
261         virCommandSetInputFD(ret->cmd, *fd);
262         virCommandSetOutputFD(ret->cmd, &pipefd[1]);
263         virCommandAddArg(ret->cmd, "0");
264     }
265
266     /* In order to catch iohelper stderr, we must change
267      * iohelper's env so virLog functions print to stderr
268      */
269     virCommandAddEnvPair(ret->cmd, "LIBVIRT_LOG_OUTPUTS", "1:stderr");
270     virCommandSetErrorBuffer(ret->cmd, &ret->err_msg);
271     virCommandDoAsyncIO(ret->cmd);
272
273     if (virCommandRunAsync(ret->cmd, NULL) < 0)
274         goto error;
275
276     if (VIR_CLOSE(pipefd[!output]) < 0) {
277         virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("unable to close pipe"));
278         goto error;
279     }
280
281     VIR_FORCE_CLOSE(*fd);
282     *fd = pipefd[output];
283     return ret;
284
285  error:
286     VIR_FREE(iohelper_path);
287     VIR_FORCE_CLOSE(pipefd[0]);
288     VIR_FORCE_CLOSE(pipefd[1]);
289     virFileWrapperFdFree(ret);
290     return NULL;
291 }
292 #else
293 virFileWrapperFdPtr
294 virFileWrapperFdNew(int *fd ATTRIBUTE_UNUSED,
295                     const char *name ATTRIBUTE_UNUSED,
296                     unsigned int fdflags ATTRIBUTE_UNUSED)
297 {
298     virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
299                  _("virFileWrapperFd unsupported on this platform"));
300     return NULL;
301 }
302 #endif
303
304 /**
305  * virFileWrapperFdClose:
306  * @wfd: fd wrapper, or NULL
307  *
308  * If @wfd is valid, then ensure that I/O has completed, which may
309  * include reaping a child process.  Return 0 if all data for the
310  * wrapped fd is complete, or -1 on failure with an error emitted.
311  * This function intentionally returns 0 when @wfd is NULL, so that
312  * callers can conditionally create a virFileWrapperFd wrapper but
313  * unconditionally call the cleanup code.  To avoid deadlock, only
314  * call this after closing the fd resulting from virFileWrapperFdNew().
315  */
316 int
317 virFileWrapperFdClose(virFileWrapperFdPtr wfd)
318 {
319     int ret;
320
321     if (!wfd)
322         return 0;
323
324     ret = virCommandWait(wfd->cmd, NULL);
325     if (wfd->err_msg)
326         VIR_WARN("iohelper reports: %s", wfd->err_msg);
327
328     return ret;
329 }
330
331 /**
332  * virFileWrapperFdFree:
333  * @wfd: fd wrapper, or NULL
334  *
335  * Free all remaining resources associated with @wfd.  If
336  * virFileWrapperFdClose() was not previously called, then this may
337  * discard some previous I/O.  To avoid deadlock, only call this after
338  * closing the fd resulting from virFileWrapperFdNew().
339  */
340 void
341 virFileWrapperFdFree(virFileWrapperFdPtr wfd)
342 {
343     if (!wfd)
344         return;
345
346     VIR_FREE(wfd->err_msg);
347
348     virCommandFree(wfd->cmd);
349     VIR_FREE(wfd);
350 }
351
352
353 #ifndef WIN32
354 /**
355  * virFileLock:
356  * @fd: file descriptor to acquire the lock on
357  * @shared: type of lock to acquire
358  * @start: byte offset to start lock
359  * @len: length of lock (0 to acquire entire remaining file from @start)
360  * @waitForLock: wait for previously held lock or not
361  *
362  * Attempt to acquire a lock on the file @fd. If @shared
363  * is true, then a shared lock will be acquired,
364  * otherwise an exclusive lock will be acquired. If
365  * the lock cannot be acquired, an error will be
366  * returned. If @waitForLock is true, this will wait
367  * for the lock if another process has already acquired it.
368  *
369  * The lock will be released when @fd is closed. The lock
370  * will also be released if *any* other open file descriptor
371  * pointing to the same underlying file is closed. As such
372  * this function should not be relied on in multi-threaded
373  * apps where other threads can be opening/closing arbitrary
374  * files.
375  *
376  * Returns 0 on success, or -errno otherwise
377  */
378 int virFileLock(int fd, bool shared, off_t start, off_t len, bool waitForLock)
379 {
380     struct flock fl = {
381         .l_type = shared ? F_RDLCK : F_WRLCK,
382         .l_whence = SEEK_SET,
383         .l_start = start,
384         .l_len = len,
385     };
386
387     int cmd = waitForLock ? F_SETLKW : F_SETLK;
388
389     if (fcntl(fd, cmd, &fl) < 0)
390         return -errno;
391
392     return 0;
393 }
394
395
396 /**
397  * virFileUnlock:
398  * @fd: file descriptor to release the lock on
399  * @start: byte offset to start unlock
400  * @len: length of lock (0 to release entire remaining file from @start)
401  *
402  * Release a lock previously acquired with virFileUnlock().
403  * NB the lock will also be released if any open file descriptor
404  * pointing to the same file as @fd is closed
405  *
406  * Returns 0 on succcess, or -errno on error
407  */
408 int virFileUnlock(int fd, off_t start, off_t len)
409 {
410     struct flock fl = {
411         .l_type = F_UNLCK,
412         .l_whence = SEEK_SET,
413         .l_start = start,
414         .l_len = len,
415     };
416
417     if (fcntl(fd, F_SETLK, &fl) < 0)
418         return -errno;
419
420     return 0;
421 }
422 #else
423 int virFileLock(int fd ATTRIBUTE_UNUSED,
424                 bool shared ATTRIBUTE_UNUSED,
425                 off_t start ATTRIBUTE_UNUSED,
426                 off_t len ATTRIBUTE_UNUSED,
427                 bool waitForLock ATTRIBUTE_UNUSED)
428 {
429     return -ENOSYS;
430 }
431 int virFileUnlock(int fd ATTRIBUTE_UNUSED,
432                   off_t start ATTRIBUTE_UNUSED,
433                   off_t len ATTRIBUTE_UNUSED)
434 {
435     return -ENOSYS;
436 }
437 #endif
438
439 int
440 virFileRewrite(const char *path,
441                mode_t mode,
442                virFileRewriteFunc rewrite,
443                void *opaque)
444 {
445     char *newfile = NULL;
446     int fd = -1;
447     int ret = -1;
448
449     if (virAsprintf(&newfile, "%s.new", path) < 0)
450         goto cleanup;
451
452     if ((fd = open(newfile, O_WRONLY | O_CREAT | O_TRUNC, mode)) < 0) {
453         virReportSystemError(errno, _("cannot create file '%s'"),
454                              newfile);
455         goto cleanup;
456     }
457
458     if (rewrite(fd, opaque) < 0) {
459         virReportSystemError(errno, _("cannot write data to file '%s'"),
460                              newfile);
461         goto cleanup;
462     }
463
464     if (fsync(fd) < 0) {
465         virReportSystemError(errno, _("cannot sync file '%s'"),
466                              newfile);
467         goto cleanup;
468     }
469
470     if (VIR_CLOSE(fd) < 0) {
471         virReportSystemError(errno, _("cannot save file '%s'"),
472                              newfile);
473         goto cleanup;
474     }
475
476     if (rename(newfile, path) < 0) {
477         virReportSystemError(errno, _("cannot rename file '%s' as '%s'"),
478                              newfile, path);
479         goto cleanup;
480     }
481
482     ret = 0;
483
484  cleanup:
485     VIR_FORCE_CLOSE(fd);
486     if (newfile) {
487         unlink(newfile);
488         VIR_FREE(newfile);
489     }
490     return ret;
491 }
492
493
494 int virFileTouch(const char *path, mode_t mode)
495 {
496     int fd = -1;
497
498     if ((fd = open(path, O_WRONLY | O_CREAT, mode)) < 0) {
499         virReportSystemError(errno, _("cannot create file '%s'"),
500                              path);
501         return -1;
502     }
503
504     if (VIR_CLOSE(fd) < 0) {
505         virReportSystemError(errno, _("cannot save file '%s'"),
506                              path);
507         VIR_FORCE_CLOSE(fd);
508         return -1;
509     }
510
511     return 0;
512 }
513
514
515 #define MODE_BITS (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
516
517 int virFileUpdatePerm(const char *path,
518                       mode_t mode_remove,
519                       mode_t mode_add)
520 {
521     struct stat sb;
522     mode_t mode;
523
524     if (mode_remove & ~MODE_BITS || mode_add & ~MODE_BITS) {
525         virReportError(VIR_ERR_INVALID_ARG, "%s", _("invalid mode"));
526         return -1;
527     }
528
529     if (stat(path, &sb) < 0) {
530         virReportSystemError(errno, _("cannot stat '%s'"), path);
531         return -1;
532     }
533
534     mode = sb.st_mode & MODE_BITS;
535
536     if ((mode & mode_remove) == 0 && (mode & mode_add) == mode_add)
537         return 0;
538
539     mode &= MODE_BITS ^ mode_remove;
540     mode |= mode_add;
541
542     if (chmod(path, mode) < 0) {
543         virReportSystemError(errno, _("cannot change permission of '%s'"),
544                              path);
545         return -1;
546     }
547
548     return 0;
549 }
550
551
552 #if defined(__linux__) && HAVE_DECL_LO_FLAGS_AUTOCLEAR && \
553     !defined(LIBVIRT_SETUID_RPC_CLIENT)
554
555 # if HAVE_DECL_LOOP_CTL_GET_FREE
556
557 /* virFileLoopDeviceOpenLoopCtl() returns -1 when a real failure has occurred
558  * while in the process of allocating or opening the loop device.  On success
559  * we return 0 and modify the fd to the appropriate file descriptor.
560  * If /dev/loop-control does not exist, we return 0 and do not set fd. */
561
562 static int virFileLoopDeviceOpenLoopCtl(char **dev_name, int *fd)
563 {
564     int devnr;
565     int ctl_fd;
566     char *looppath = NULL;
567
568     VIR_DEBUG("Opening loop-control device");
569     if ((ctl_fd = open("/dev/loop-control", O_RDWR)) < 0) {
570         if (errno == ENOENT)
571             return 0;
572
573         virReportSystemError(errno, "%s",
574                              _("Unable to open /dev/loop-control"));
575         return -1;
576     }
577
578     if ((devnr = ioctl(ctl_fd, LOOP_CTL_GET_FREE)) < 0) {
579         virReportSystemError(errno, "%s",
580                              _("Unable to get free loop device via ioctl"));
581         close(ctl_fd);
582         return -1;
583     }
584     close(ctl_fd);
585
586     VIR_DEBUG("Found free loop device number %i", devnr);
587
588     if (virAsprintf(&looppath, "/dev/loop%i", devnr) < 0)
589         return -1;
590
591     if ((*fd = open(looppath, O_RDWR)) < 0) {
592         virReportSystemError(errno,
593                 _("Unable to open %s"), looppath);
594         VIR_FREE(looppath);
595         return -1;
596     }
597
598     *dev_name = looppath;
599     return 0;
600 }
601 # endif /* HAVE_DECL_LOOP_CTL_GET_FREE */
602
603 static int virFileLoopDeviceOpenSearch(char **dev_name)
604 {
605     int fd = -1;
606     DIR *dh = NULL;
607     struct dirent *de;
608     char *looppath = NULL;
609     struct loop_info64 lo;
610     int direrr;
611
612     VIR_DEBUG("Looking for loop devices in /dev");
613
614     if (!(dh = opendir("/dev"))) {
615         virReportSystemError(errno, "%s",
616                              _("Unable to read /dev"));
617         goto cleanup;
618     }
619
620     while ((direrr = virDirRead(dh, &de, "/dev")) > 0) {
621         /* Checking 'loop' prefix is insufficient, since
622          * new kernels have a dev named 'loop-control'
623          */
624         if (!STRPREFIX(de->d_name, "loop") ||
625             !c_isdigit(de->d_name[4]))
626             continue;
627
628         if (virAsprintf(&looppath, "/dev/%s", de->d_name) < 0)
629             goto cleanup;
630
631         VIR_DEBUG("Checking up on device %s", looppath);
632         if ((fd = open(looppath, O_RDWR)) < 0) {
633             virReportSystemError(errno,
634                                  _("Unable to open %s"), looppath);
635             goto cleanup;
636         }
637
638         if (ioctl(fd, LOOP_GET_STATUS64, &lo) < 0) {
639             /* Got a free device, return the fd */
640             if (errno == ENXIO)
641                 goto cleanup;
642
643             VIR_FORCE_CLOSE(fd);
644             virReportSystemError(errno,
645                                  _("Unable to get loop status on %s"),
646                                  looppath);
647             goto cleanup;
648         }
649
650         /* Oh well, try the next device */
651         VIR_FORCE_CLOSE(fd);
652         VIR_FREE(looppath);
653     }
654     if (direrr < 0)
655         goto cleanup;
656     virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
657                    _("Unable to find a free loop device in /dev"));
658
659  cleanup:
660     if (fd != -1) {
661         VIR_DEBUG("Got free loop device %s %d", looppath, fd);
662         *dev_name = looppath;
663     } else {
664         VIR_DEBUG("No free loop devices available");
665         VIR_FREE(looppath);
666     }
667     if (dh)
668         closedir(dh);
669     return fd;
670 }
671
672 static int virFileLoopDeviceOpen(char **dev_name)
673 {
674     int loop_fd = -1;
675
676 # if HAVE_DECL_LOOP_CTL_GET_FREE
677     if (virFileLoopDeviceOpenLoopCtl(dev_name, &loop_fd) < 0)
678         return -1;
679
680     VIR_DEBUG("Return from loop-control got fd %d\n", loop_fd);
681
682     if (loop_fd >= 0)
683         return loop_fd;
684 # endif /* HAVE_DECL_LOOP_CTL_GET_FREE */
685
686     /* Without the loop control device we just use the old technique. */
687     loop_fd = virFileLoopDeviceOpenSearch(dev_name);
688
689     return loop_fd;
690 }
691
692 int virFileLoopDeviceAssociate(const char *file,
693                                char **dev)
694 {
695     int lofd = -1;
696     int fsfd = -1;
697     struct loop_info64 lo;
698     char *loname = NULL;
699     int ret = -1;
700
701     if ((lofd = virFileLoopDeviceOpen(&loname)) < 0)
702         return -1;
703
704     memset(&lo, 0, sizeof(lo));
705     lo.lo_flags = LO_FLAGS_AUTOCLEAR;
706
707     if ((fsfd = open(file, O_RDWR)) < 0) {
708         virReportSystemError(errno,
709                              _("Unable to open %s"), file);
710         goto cleanup;
711     }
712
713     if (ioctl(lofd, LOOP_SET_FD, fsfd) < 0) {
714         virReportSystemError(errno,
715                              _("Unable to attach %s to loop device"),
716                              file);
717         goto cleanup;
718     }
719
720     if (ioctl(lofd, LOOP_SET_STATUS64, &lo) < 0) {
721         virReportSystemError(errno, "%s",
722                              _("Unable to mark loop device as autoclear"));
723
724         if (ioctl(lofd, LOOP_CLR_FD, 0) < 0)
725             VIR_WARN("Unable to detach %s from loop device", file);
726         goto cleanup;
727     }
728
729     VIR_DEBUG("Attached loop device  %s %d to %s", file, lofd, loname);
730     *dev = loname;
731     loname = NULL;
732
733     ret = 0;
734
735  cleanup:
736     VIR_FREE(loname);
737     VIR_FORCE_CLOSE(fsfd);
738     if (ret == -1)
739         VIR_FORCE_CLOSE(lofd);
740     return lofd;
741 }
742
743
744 # define SYSFS_BLOCK_DIR "/sys/block"
745
746
747 static int
748 virFileNBDDeviceIsBusy(const char *devname)
749 {
750     char *path;
751     int ret = -1;
752
753     if (virAsprintf(&path, SYSFS_BLOCK_DIR "/%s/pid",
754                     devname) < 0)
755         return -1;
756
757     if (!virFileExists(path)) {
758         if (errno == ENOENT)
759             ret = 0;
760         else
761             virReportSystemError(errno,
762                                  _("Cannot check NBD device %s pid"),
763                                  devname);
764         goto cleanup;
765     }
766     ret = 1;
767
768  cleanup:
769     VIR_FREE(path);
770     return ret;
771 }
772
773
774 static char *
775 virFileNBDDeviceFindUnused(void)
776 {
777     DIR *dh;
778     char *ret = NULL;
779     struct dirent *de;
780     int direrr;
781
782     if (!(dh = opendir(SYSFS_BLOCK_DIR))) {
783         virReportSystemError(errno,
784                              _("Cannot read directory %s"),
785                              SYSFS_BLOCK_DIR);
786         return NULL;
787     }
788
789     while ((direrr = virDirRead(dh, &de, SYSFS_BLOCK_DIR)) > 0) {
790         if (STRPREFIX(de->d_name, "nbd")) {
791             int rv = virFileNBDDeviceIsBusy(de->d_name);
792             if (rv < 0)
793                 goto cleanup;
794             if (rv == 0) {
795                 if (virAsprintf(&ret, "/dev/%s", de->d_name) < 0)
796                     goto cleanup;
797                 goto cleanup;
798             }
799         }
800     }
801     if (direrr < 0)
802         goto cleanup;
803     virReportSystemError(EBUSY, "%s",
804                          _("No free NBD devices"));
805
806  cleanup:
807     closedir(dh);
808     return ret;
809 }
810
811
812 int virFileNBDDeviceAssociate(const char *file,
813                               enum virStorageFileFormat fmt,
814                               bool readonly,
815                               char **dev)
816 {
817     char *nbddev;
818     char *qemunbd = NULL;
819     virCommandPtr cmd = NULL;
820     int ret = -1;
821     const char *fmtstr = NULL;
822
823     if (!(nbddev = virFileNBDDeviceFindUnused()))
824         goto cleanup;
825
826     if (!(qemunbd = virFindFileInPath("qemu-nbd"))) {
827         virReportSystemError(ENOENT, "%s",
828                              _("Unable to find 'qemu-nbd' binary in $PATH"));
829         goto cleanup;
830     }
831
832     if (fmt > 0)
833         fmtstr = virStorageFileFormatTypeToString(fmt);
834
835     cmd = virCommandNew(qemunbd);
836
837     /* Explicitly not trying to cope with old qemu-nbd which
838      * lacked --format. We want to see a fatal error in that
839      * case since it would be security flaw to continue */
840     if (fmtstr)
841         virCommandAddArgList(cmd, "--format", fmtstr, NULL);
842
843     if (readonly)
844         virCommandAddArg(cmd, "-r");
845
846     virCommandAddArgList(cmd,
847                          "-n", /* Don't cache in qemu-nbd layer */
848                          "-c", nbddev,
849                          file, NULL);
850
851     /* qemu-nbd will daemonize itself */
852
853     if (virCommandRun(cmd, NULL) < 0)
854         goto cleanup;
855
856     VIR_DEBUG("Associated NBD device %s with file %s and format %s",
857               nbddev, file, fmtstr);
858     *dev = nbddev;
859     nbddev = NULL;
860     ret = 0;
861
862  cleanup:
863     VIR_FREE(nbddev);
864     VIR_FREE(qemunbd);
865     virCommandFree(cmd);
866     return ret;
867 }
868
869 #else /* __linux__ */
870
871 int virFileLoopDeviceAssociate(const char *file,
872                                char **dev ATTRIBUTE_UNUSED)
873 {
874     virReportSystemError(ENOSYS,
875                          _("Unable to associate file %s with loop device"),
876                          file);
877     *dev = NULL;
878     return -1;
879 }
880
881 int virFileNBDDeviceAssociate(const char *file,
882                               enum virStorageFileFormat fmt ATTRIBUTE_UNUSED,
883                               bool readonly ATTRIBUTE_UNUSED,
884                               char **dev ATTRIBUTE_UNUSED)
885 {
886     virReportSystemError(ENOSYS,
887                          _("Unable to associate file %s with NBD device"),
888                          file);
889     return -1;
890 }
891
892 #endif /* __linux__ */
893
894
895 /**
896  * virFileDeleteTree:
897  *
898  * Recursively deletes all files / directories
899  * starting from the directory @dir. Does not
900  * follow symlinks
901  *
902  * NB the algorithm is not efficient, and is subject to
903  * race conditions which can be exploited by malicious
904  * code. It should not be used in any scenarios where
905  * performance is important, or security is critical.
906  */
907 int virFileDeleteTree(const char *dir)
908 {
909     DIR *dh = opendir(dir);
910     struct dirent *de;
911     char *filepath = NULL;
912     int ret = -1;
913     int direrr;
914
915     if (!dh) {
916         virReportSystemError(errno, _("Cannot open dir '%s'"),
917                              dir);
918         return -1;
919     }
920
921     while ((direrr = virDirRead(dh, &de, dir)) > 0) {
922         struct stat sb;
923
924         if (STREQ(de->d_name, ".") ||
925             STREQ(de->d_name, ".."))
926             continue;
927
928         if (virAsprintf(&filepath, "%s/%s",
929                         dir, de->d_name) < 0)
930             goto cleanup;
931
932         if (lstat(filepath, &sb) < 0) {
933             virReportSystemError(errno, _("Cannot access '%s'"),
934                                  filepath);
935             goto cleanup;
936         }
937
938         if (S_ISDIR(sb.st_mode)) {
939             if (virFileDeleteTree(filepath) < 0)
940                 goto cleanup;
941         } else {
942             if (unlink(filepath) < 0 && errno != ENOENT) {
943                 virReportSystemError(errno,
944                                      _("Cannot delete file '%s'"),
945                                      filepath);
946                 goto cleanup;
947             }
948         }
949
950         VIR_FREE(filepath);
951     }
952     if (direrr < 0)
953         goto cleanup;
954
955     if (rmdir(dir) < 0 && errno != ENOENT) {
956         virReportSystemError(errno,
957                              _("Cannot delete directory '%s'"),
958                              dir);
959         goto cleanup;
960     }
961
962     ret = 0;
963
964  cleanup:
965     VIR_FREE(filepath);
966     closedir(dh);
967     return ret;
968 }
969
970 int
971 virFileStripSuffix(char *str, const char *suffix)
972 {
973     int len = strlen(str);
974     int suffixlen = strlen(suffix);
975
976     if (len < suffixlen)
977         return 0;
978
979     if (!STREQ(str + len - suffixlen, suffix))
980         return 0;
981
982     str[len-suffixlen] = '\0';
983
984     return 1;
985 }
986
987
988 /* Like read(), but restarts after EINTR.  Doesn't play
989  * nicely with nonblocking FD and EAGAIN, in which case
990  * you want to use bare read(). Or even use virSocket()
991  * if the FD is related to a socket rather than a plain
992  * file or pipe. */
993 ssize_t
994 saferead(int fd, void *buf, size_t count)
995 {
996     size_t nread = 0;
997     while (count > 0) {
998         ssize_t r = read(fd, buf, count);
999         if (r < 0 && errno == EINTR)
1000             continue;
1001         if (r < 0)
1002             return r;
1003         if (r == 0)
1004             return nread;
1005         buf = (char *)buf + r;
1006         count -= r;
1007         nread += r;
1008     }
1009     return nread;
1010 }
1011
1012 /* Like write(), but restarts after EINTR. Doesn't play
1013  * nicely with nonblocking FD and EAGAIN, in which case
1014  * you want to use bare write(). Or even use virSocket()
1015  * if the FD is related to a socket rather than a plain
1016  * file or pipe. */
1017 ssize_t
1018 safewrite(int fd, const void *buf, size_t count)
1019 {
1020     size_t nwritten = 0;
1021     while (count > 0) {
1022         ssize_t r = write(fd, buf, count);
1023
1024         if (r < 0 && errno == EINTR)
1025             continue;
1026         if (r < 0)
1027             return r;
1028         if (r == 0)
1029             return nwritten;
1030         buf = (const char *)buf + r;
1031         count -= r;
1032         nwritten += r;
1033     }
1034     return nwritten;
1035 }
1036
1037 #ifdef HAVE_POSIX_FALLOCATE
1038 int
1039 safezero(int fd, off_t offset, off_t len)
1040 {
1041     int ret = posix_fallocate(fd, offset, len);
1042     if (ret == 0)
1043         return 0;
1044     errno = ret;
1045     return -1;
1046 }
1047
1048 #else
1049
1050 int
1051 safezero(int fd, off_t offset, off_t len)
1052 {
1053     int r;
1054     char *buf;
1055     unsigned long long remain, bytes;
1056 # ifdef HAVE_MMAP
1057     static long pagemask = 0;
1058     off_t map_skip;
1059
1060     /* align offset and length, rounding offset down and length up */
1061     if (pagemask == 0)
1062         pagemask = ~(sysconf(_SC_PAGESIZE) - 1);
1063     map_skip = offset - (offset & pagemask);
1064
1065     /* memset wants the mmap'ed file to be present on disk so create a
1066      * sparse file
1067      */
1068     r = ftruncate(fd, offset + len);
1069     if (r < 0)
1070         return -1;
1071
1072     buf = mmap(NULL, len + map_skip, PROT_READ | PROT_WRITE, MAP_SHARED,
1073                fd, offset - map_skip);
1074     if (buf != MAP_FAILED) {
1075         memset(buf + map_skip, 0, len);
1076         munmap(buf, len + map_skip);
1077
1078         return 0;
1079     }
1080
1081     /* fall back to writing zeroes using safewrite if mmap fails (for
1082      * example because of virtual memory limits) */
1083 # endif /* HAVE_MMAP */
1084
1085     if (lseek(fd, offset, SEEK_SET) < 0)
1086         return -1;
1087
1088     /* Split up the write in small chunks so as not to allocate lots of RAM */
1089     remain = len;
1090     bytes = MIN(1024 * 1024, len);
1091
1092     r = VIR_ALLOC_N(buf, bytes);
1093     if (r < 0) {
1094         errno = ENOMEM;
1095         return -1;
1096     }
1097
1098     while (remain) {
1099         if (bytes > remain)
1100             bytes = remain;
1101
1102         r = safewrite(fd, buf, bytes);
1103         if (r < 0) {
1104             VIR_FREE(buf);
1105             return -1;
1106         }
1107
1108         /* safewrite() guarantees all data will be written */
1109         remain -= bytes;
1110     }
1111     VIR_FREE(buf);
1112     return 0;
1113 }
1114 #endif /* HAVE_POSIX_FALLOCATE */
1115
1116
1117 #if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
1118 /* search /proc/mounts for mount point of *type; return pointer to
1119  * malloc'ed string of the path if found, otherwise return NULL
1120  * with errno set to an appropriate value.
1121  */
1122 char *
1123 virFileFindMountPoint(const char *type)
1124 {
1125     FILE *f;
1126     struct mntent mb;
1127     char mntbuf[1024];
1128     char *ret = NULL;
1129
1130     f = setmntent("/proc/mounts", "r");
1131     if (!f)
1132         return NULL;
1133
1134     while (getmntent_r(f, &mb, mntbuf, sizeof(mntbuf))) {
1135         if (STREQ(mb.mnt_type, type)) {
1136             ignore_value(VIR_STRDUP_QUIET(ret, mb.mnt_dir));
1137             goto cleanup;
1138         }
1139     }
1140
1141     if (!ret)
1142         errno = ENOENT;
1143
1144  cleanup:
1145     endmntent(f);
1146
1147     return ret;
1148 }
1149
1150 #else /* defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R */
1151
1152 char *
1153 virFileFindMountPoint(const char *type ATTRIBUTE_UNUSED)
1154 {
1155     errno = ENOSYS;
1156
1157     return NULL;
1158 }
1159
1160 #endif /* defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R */
1161
1162 int
1163 virBuildPathInternal(char **path, ...)
1164 {
1165     char *path_component = NULL;
1166     virBuffer buf = VIR_BUFFER_INITIALIZER;
1167     va_list ap;
1168     int ret = 0;
1169
1170     va_start(ap, path);
1171
1172     path_component = va_arg(ap, char *);
1173     virBufferAdd(&buf, path_component, -1);
1174
1175     while ((path_component = va_arg(ap, char *)) != NULL)
1176     {
1177         virBufferAddChar(&buf, '/');
1178         virBufferAdd(&buf, path_component, -1);
1179     }
1180
1181     va_end(ap);
1182
1183     *path = virBufferContentAndReset(&buf);
1184     if (*path == NULL) {
1185         ret = -1;
1186     }
1187
1188     return ret;
1189 }
1190
1191 /* Like gnulib's fread_file, but read no more than the specified maximum
1192    number of bytes.  If the length of the input is <= max_len, and
1193    upon error while reading that data, it works just like fread_file.  */
1194 static char *
1195 saferead_lim(int fd, size_t max_len, size_t *length)
1196 {
1197     char *buf = NULL;
1198     size_t alloc = 0;
1199     size_t size = 0;
1200     int save_errno;
1201
1202     for (;;) {
1203         int count;
1204         int requested;
1205
1206         if (size + BUFSIZ + 1 > alloc) {
1207             alloc += alloc / 2;
1208             if (alloc < size + BUFSIZ + 1)
1209                 alloc = size + BUFSIZ + 1;
1210
1211             if (VIR_REALLOC_N(buf, alloc) < 0) {
1212                 save_errno = errno;
1213                 break;
1214             }
1215         }
1216
1217         /* Ensure that (size + requested <= max_len); */
1218         requested = MIN(size < max_len ? max_len - size : 0,
1219                         alloc - size - 1);
1220         count = saferead(fd, buf + size, requested);
1221         size += count;
1222
1223         if (count != requested || requested == 0) {
1224             save_errno = errno;
1225             if (count < 0)
1226                 break;
1227             buf[size] = '\0';
1228             *length = size;
1229             return buf;
1230         }
1231     }
1232
1233     VIR_FREE(buf);
1234     errno = save_errno;
1235     return NULL;
1236 }
1237
1238
1239 /* A wrapper around saferead_lim that merely stops reading at the
1240  * specified maximum size.  */
1241 int
1242 virFileReadHeaderFD(int fd, int maxlen, char **buf)
1243 {
1244     size_t len;
1245     char *s;
1246
1247     if (maxlen <= 0) {
1248         errno = EINVAL;
1249         return -1;
1250     }
1251     s = saferead_lim(fd, maxlen, &len);
1252     if (s == NULL)
1253         return -1;
1254     *buf = s;
1255     return len;
1256 }
1257
1258
1259 /* A wrapper around saferead_lim that maps a failure due to
1260    exceeding the maximum size limitation to EOVERFLOW.  */
1261 int
1262 virFileReadLimFD(int fd, int maxlen, char **buf)
1263 {
1264     size_t len;
1265     char *s;
1266
1267     if (maxlen <= 0) {
1268         errno = EINVAL;
1269         return -1;
1270     }
1271     s = saferead_lim(fd, maxlen+1, &len);
1272     if (s == NULL)
1273         return -1;
1274     if (len > maxlen || (int)len != len) {
1275         VIR_FREE(s);
1276         /* There was at least one byte more than MAXLEN.
1277            Set errno accordingly. */
1278         errno = EOVERFLOW;
1279         return -1;
1280     }
1281     *buf = s;
1282     return len;
1283 }
1284
1285 int
1286 virFileReadAll(const char *path, int maxlen, char **buf)
1287 {
1288     int fd = open(path, O_RDONLY);
1289     if (fd < 0) {
1290         virReportSystemError(errno, _("Failed to open file '%s'"), path);
1291         return -1;
1292     }
1293
1294     int len = virFileReadLimFD(fd, maxlen, buf);
1295     VIR_FORCE_CLOSE(fd);
1296     if (len < 0) {
1297         virReportSystemError(errno, _("Failed to read file '%s'"), path);
1298         return -1;
1299     }
1300
1301     return len;
1302 }
1303
1304 /* Truncate @path and write @str to it.  If @mode is 0, ensure that
1305    @path exists; otherwise, use @mode if @path must be created.
1306    Return 0 for success, nonzero for failure.
1307    Be careful to preserve any errno value upon failure. */
1308 int
1309 virFileWriteStr(const char *path, const char *str, mode_t mode)
1310 {
1311     int fd;
1312
1313     if (mode)
1314         fd = open(path, O_WRONLY|O_TRUNC|O_CREAT, mode);
1315     else
1316         fd = open(path, O_WRONLY|O_TRUNC);
1317     if (fd == -1)
1318         return -1;
1319
1320     if (safewrite(fd, str, strlen(str)) < 0) {
1321         VIR_FORCE_CLOSE(fd);
1322         return -1;
1323     }
1324
1325     /* Use errno from failed close only if there was no write error.  */
1326     if (VIR_CLOSE(fd) != 0)
1327         return -1;
1328
1329     return 0;
1330 }
1331
1332 int
1333 virFileMatchesNameSuffix(const char *file,
1334                          const char *name,
1335                          const char *suffix)
1336 {
1337     int filelen = strlen(file);
1338     int namelen = strlen(name);
1339     int suffixlen = strlen(suffix);
1340
1341     if (filelen == (namelen + suffixlen) &&
1342         STREQLEN(file, name, namelen) &&
1343         STREQLEN(file + namelen, suffix, suffixlen))
1344         return 1;
1345     else
1346         return 0;
1347 }
1348
1349 int
1350 virFileHasSuffix(const char *str,
1351                  const char *suffix)
1352 {
1353     int len = strlen(str);
1354     int suffixlen = strlen(suffix);
1355
1356     if (len < suffixlen)
1357         return 0;
1358
1359     return STRCASEEQ(str + len - suffixlen, suffix);
1360 }
1361
1362 #define SAME_INODE(Stat_buf_1, Stat_buf_2) \
1363   ((Stat_buf_1).st_ino == (Stat_buf_2).st_ino \
1364    && (Stat_buf_1).st_dev == (Stat_buf_2).st_dev)
1365
1366 /* Return nonzero if checkLink and checkDest
1367  * refer to the same file.  Otherwise, return 0.
1368  */
1369 int
1370 virFileLinkPointsTo(const char *checkLink,
1371                     const char *checkDest)
1372 {
1373     struct stat src_sb;
1374     struct stat dest_sb;
1375
1376     return (stat(checkLink, &src_sb) == 0
1377             && stat(checkDest, &dest_sb) == 0
1378             && SAME_INODE(src_sb, dest_sb));
1379 }
1380
1381
1382 /* Return positive if checkLink (residing within directory if not
1383  * absolute) and checkDest refer to the same file.  Otherwise, return
1384  * -1 on allocation failure (error reported), or 0 if not the same
1385  * (silent).
1386  */
1387 int
1388 virFileRelLinkPointsTo(const char *directory,
1389                        const char *checkLink,
1390                        const char *checkDest)
1391 {
1392     char *candidate;
1393     int ret;
1394
1395     if (*checkLink == '/')
1396         return virFileLinkPointsTo(checkLink, checkDest);
1397     if (!directory) {
1398         virReportError(VIR_ERR_INTERNAL_ERROR,
1399                        _("cannot resolve '%s' without starting directory"),
1400                        checkLink);
1401         return -1;
1402     }
1403     if (virAsprintf(&candidate, "%s/%s", directory, checkLink) < 0)
1404         return -1;
1405     ret = virFileLinkPointsTo(candidate, checkDest);
1406     VIR_FREE(candidate);
1407     return ret;
1408 }
1409
1410
1411 static int
1412 virFileResolveLinkHelper(const char *linkpath,
1413                          bool intermediatePaths,
1414                          char **resultpath)
1415 {
1416     struct stat st;
1417
1418     *resultpath = NULL;
1419
1420     /* We don't need the full canonicalization of intermediate
1421      * directories, if linkpath is absolute and the basename is
1422      * already a non-symlink.  */
1423     if (IS_ABSOLUTE_FILE_NAME(linkpath) && !intermediatePaths) {
1424         if (lstat(linkpath, &st) < 0)
1425             return -1;
1426
1427         if (!S_ISLNK(st.st_mode))
1428             return VIR_STRDUP_QUIET(*resultpath, linkpath) < 0 ? -1 : 0;
1429     }
1430
1431     *resultpath = canonicalize_file_name(linkpath);
1432
1433     return *resultpath == NULL ? -1 : 0;
1434 }
1435
1436 /*
1437  * Attempt to resolve a symbolic link, returning an
1438  * absolute path where only the last component is guaranteed
1439  * not to be a symlink.
1440  *
1441  * Return 0 if path was not a symbolic, or the link was
1442  * resolved. Return -1 with errno set upon error
1443  */
1444 int
1445 virFileResolveLink(const char *linkpath, char **resultpath)
1446 {
1447     return virFileResolveLinkHelper(linkpath, false, resultpath);
1448 }
1449
1450 /*
1451  * Attempt to resolve a symbolic link, returning an
1452  * absolute path where every component is guaranteed
1453  * not to be a symlink.
1454  *
1455  * Return 0 if path was not a symbolic, or the link was
1456  * resolved. Return -1 with errno set upon error
1457  */
1458 int
1459 virFileResolveAllLinks(const char *linkpath, char **resultpath)
1460 {
1461     return virFileResolveLinkHelper(linkpath, true, resultpath);
1462 }
1463
1464 /*
1465  * Check whether the given file is a link.
1466  * Returns 1 in case of the file being a link, 0 in case it is not
1467  * a link and the negative errno in all other cases.
1468  */
1469 int
1470 virFileIsLink(const char *linkpath)
1471 {
1472     struct stat st;
1473
1474     if (lstat(linkpath, &st) < 0)
1475         return -errno;
1476
1477     return S_ISLNK(st.st_mode) != 0;
1478 }
1479
1480
1481 /*
1482  * Finds a requested executable file in the PATH env. e.g.:
1483  * "kvm-img" will return "/usr/bin/kvm-img"
1484  *
1485  * You must free the result
1486  */
1487 char *
1488 virFindFileInPath(const char *file)
1489 {
1490     const char *origpath = NULL;
1491     char *path = NULL;
1492     char *pathiter;
1493     char *pathseg;
1494     char *fullpath = NULL;
1495
1496     if (file == NULL)
1497         return NULL;
1498
1499     /* if we are passed an absolute path (starting with /), return a
1500      * copy of that path, after validating that it is executable
1501      */
1502     if (IS_ABSOLUTE_FILE_NAME(file)) {
1503         char *ret = NULL;
1504         if (virFileIsExecutable(file))
1505             ignore_value(VIR_STRDUP_QUIET(ret, file));
1506         return ret;
1507     }
1508
1509     /* If we are passed an anchored path (containing a /), then there
1510      * is no path search - it must exist in the current directory
1511      */
1512     if (strchr(file, '/')) {
1513         if (virFileIsExecutable(file))
1514             ignore_value(virFileAbsPath(file, &path));
1515         return path;
1516     }
1517
1518     /* copy PATH env so we can tweak it */
1519     origpath = virGetEnvBlockSUID("PATH");
1520     if (!origpath)
1521         origpath = "/bin:/usr/bin";
1522
1523     if (VIR_STRDUP_QUIET(path, origpath) <= 0)
1524         return NULL;
1525
1526     /* for each path segment, append the file to search for and test for
1527      * it. return it if found.
1528      */
1529     pathiter = path;
1530     while ((pathseg = strsep(&pathiter, ":")) != NULL) {
1531         if (virAsprintf(&fullpath, "%s/%s", pathseg, file) < 0 ||
1532             virFileIsExecutable(fullpath))
1533             break;
1534         VIR_FREE(fullpath);
1535     }
1536
1537     VIR_FREE(path);
1538     return fullpath;
1539 }
1540
1541
1542 static bool useDirOverride;
1543
1544 /**
1545  * virFileFindResourceFull:
1546  * @filename: libvirt distributed filename without any path
1547  * @prefix: optional string to prepend to filename
1548  * @suffix: optional string to append to filename
1549  * @builddir: location of the binary in the source tree build tree
1550  * @installdir: location of the installed binary
1551  * @envname: environment variable used to override all dirs
1552  *
1553  * A helper which will return a path to @filename within
1554  * the current build tree, if the calling binary is being
1555  * run from the source tree. Otherwise it will return the
1556  * path in the installed location.
1557  *
1558  * If @envname is non-NULL it will override all other
1559  * directory lookup
1560  *
1561  * Only use this with @filename files that are part of
1562  * the libvirt tree, not 3rd party binaries/files.
1563  *
1564  * Returns the resolved path (caller frees) or NULL on error
1565  */
1566 char *
1567 virFileFindResourceFull(const char *filename,
1568                         const char *prefix,
1569                         const char *suffix,
1570                         const char *builddir,
1571                         const char *installdir,
1572                         const char *envname)
1573 {
1574     char *ret = NULL;
1575     const char *envval = envname ? virGetEnvBlockSUID(envname) : NULL;
1576
1577     if (!prefix)
1578         prefix = "";
1579     if (!suffix)
1580         suffix = "";
1581
1582     if (envval) {
1583         if (virAsprintf(&ret, "%s/%s%s%s", envval, prefix, filename, suffix) < 0)
1584             return NULL;
1585     } else if (useDirOverride) {
1586         if (virAsprintf(&ret, "%s/%s/%s%s%s", abs_topbuilddir, builddir, prefix, filename, suffix) < 0)
1587             return NULL;
1588     } else {
1589         if (virAsprintf(&ret, "%s/%s%s%s", installdir, prefix, filename, suffix) < 0)
1590             return NULL;
1591     }
1592
1593     VIR_DEBUG("Resolved '%s' to '%s'", filename, ret);
1594     return ret;
1595 }
1596
1597 char *
1598 virFileFindResource(const char *filename,
1599                     const char *builddir,
1600                     const char *installdir)
1601 {
1602     return virFileFindResourceFull(filename, NULL, NULL, builddir, installdir, NULL);
1603 }
1604
1605
1606 /**
1607  * virFileActivateDirOverride:
1608  * @argv0: argv[0] of the calling program
1609  *
1610  * Look at @argv0 and try to detect if running from
1611  * a build directory, by looking for a 'lt-' prefix
1612  * on the binary name, or '/.libs/' in the path
1613  */
1614 void
1615 virFileActivateDirOverride(const char *argv0)
1616 {
1617     char *file = strrchr(argv0, '/');
1618     if (!file || file[1] == '\0')
1619         return;
1620     file++;
1621     if (STRPREFIX(file, "lt-") ||
1622         strstr(argv0, "/.libs/")) {
1623         useDirOverride = true;
1624         VIR_DEBUG("Activating build dir override for %s", argv0);
1625     }
1626 }
1627
1628 bool
1629 virFileIsDir(const char *path)
1630 {
1631     struct stat s;
1632     return (stat(path, &s) == 0) && S_ISDIR(s.st_mode);
1633 }
1634
1635 /**
1636  * virFileExists: Check for presence of file
1637  * @path: Path of file to check
1638  *
1639  * Returns if the file exists. Preserves errno in case it does not exist.
1640  */
1641 bool
1642 virFileExists(const char *path)
1643 {
1644     return access(path, F_OK) == 0;
1645 }
1646
1647 /* Check that a file is regular and has executable bits.  If false is
1648  * returned, errno is valid.
1649  *
1650  * Note: In the presence of ACLs, this may return true for a file that
1651  * would actually fail with EACCES for a given user, or false for a
1652  * file that the user could actually execute, but setups with ACLs
1653  * that weird are unusual. */
1654 bool
1655 virFileIsExecutable(const char *file)
1656 {
1657     struct stat sb;
1658
1659     /* We would also want to check faccessat if we cared about ACLs,
1660      * but we don't.  */
1661     if (stat(file, &sb) < 0)
1662         return false;
1663     if (S_ISREG(sb.st_mode) && (sb.st_mode & 0111) != 0)
1664         return true;
1665     errno = S_ISDIR(sb.st_mode) ? EISDIR : EACCES;
1666     return false;
1667 }
1668
1669
1670 /*
1671  * Check that a file refers to a mount point. Trick is that for
1672  * a mount point, the st_dev field will differ from the parent
1673  * directory.
1674  *
1675  * Note that this will not detect bind mounts of dirs/files,
1676  * only true filesystem mounts.
1677  */
1678 int virFileIsMountPoint(const char *file)
1679 {
1680     char *parent = NULL;
1681     int ret = -1;
1682     struct stat sb1, sb2;
1683
1684     if (!(parent = mdir_name(file))) {
1685         virReportOOMError();
1686         goto cleanup;
1687     }
1688
1689     VIR_DEBUG("Comparing '%s' to '%s'", file, parent);
1690
1691     if (stat(file, &sb1) < 0) {
1692         if (errno == ENOENT)
1693             ret = 0;
1694         else
1695             virReportSystemError(errno,
1696                                  _("Cannot stat '%s'"),
1697                                  file);
1698         goto cleanup;
1699     }
1700
1701     if (stat(parent, &sb2) < 0) {
1702         virReportSystemError(errno,
1703                              _("Cannot stat '%s'"),
1704                              parent);
1705         goto cleanup;
1706     }
1707
1708     if (!S_ISDIR(sb1.st_mode)) {
1709         ret = 0;
1710         goto cleanup;
1711     }
1712
1713     ret = sb1.st_dev != sb2.st_dev;
1714     VIR_DEBUG("Is mount %d", ret);
1715
1716  cleanup:
1717     VIR_FREE(parent);
1718     return ret;
1719 }
1720
1721
1722 #if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
1723 static int
1724 virFileGetMountSubtreeImpl(const char *mtabpath,
1725                            const char *prefix,
1726                            char ***mountsret,
1727                            size_t *nmountsret,
1728                            bool reverse)
1729 {
1730     FILE *procmnt;
1731     struct mntent mntent;
1732     char mntbuf[1024];
1733     int ret = -1;
1734     char **mounts = NULL;
1735     size_t nmounts = 0;
1736
1737     VIR_DEBUG("prefix=%s", prefix);
1738
1739     *mountsret = NULL;
1740     *nmountsret = 0;
1741
1742     if (!(procmnt = setmntent(mtabpath, "r"))) {
1743         virReportSystemError(errno,
1744                              _("Failed to read %s"), mtabpath);
1745         return -1;
1746     }
1747
1748     while (getmntent_r(procmnt, &mntent, mntbuf, sizeof(mntbuf)) != NULL) {
1749         if (!(STREQ(mntent.mnt_dir, prefix) ||
1750               (STRPREFIX(mntent.mnt_dir, prefix) &&
1751                mntent.mnt_dir[strlen(prefix)] == '/')))
1752             continue;
1753
1754         if (VIR_EXPAND_N(mounts, nmounts, nmounts ? 1 : 2) < 0)
1755             goto cleanup;
1756         if (VIR_STRDUP(mounts[nmounts - 2], mntent.mnt_dir) < 0)
1757             goto cleanup;
1758     }
1759
1760     if (mounts)
1761         qsort(mounts, nmounts - 1, sizeof(mounts[0]),
1762               reverse ? virStringSortRevCompare : virStringSortCompare);
1763
1764     *mountsret = mounts;
1765     *nmountsret = nmounts ? nmounts - 1 : 0;
1766     ret = 0;
1767
1768  cleanup:
1769     if (ret < 0)
1770         virStringFreeList(mounts);
1771     endmntent(procmnt);
1772     return ret;
1773 }
1774 #else /* ! defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R */
1775 static int
1776 virFileGetMountSubtreeImpl(const char *mtabpath ATTRIBUTE_UNUSED,
1777                            const char *prefix ATTRIBUTE_UNUSED,
1778                            char ***mountsret ATTRIBUTE_UNUSED,
1779                            size_t *nmountsret ATTRIBUTE_UNUSED,
1780                            bool reverse ATTRIBUTE_UNUSED)
1781 {
1782     virReportSystemError(ENOSYS, "%s",
1783                          _("Unable to determine mount table on this platform"));
1784     return -1;
1785 }
1786 #endif /* ! defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R */
1787
1788 /**
1789  * virFileGetMountSubtree:
1790  * @mtabpath: mount file to parser (eg /proc/mounts)
1791  * @prefix: mount path prefix to match
1792  * @mountsret: allocated and filled with matching mounts
1793  * @nmountsret: filled with number of matching mounts, not counting NULL terminator
1794  *
1795  * Return the list of mounts from @mtabpath which contain
1796  * the path @prefix, sorted from shortest to longest path.
1797  *
1798  * The @mountsret array will be NULL terminated and should
1799  * be freed with virStringFreeList
1800  *
1801  * Returns 0 on success, -1 on error
1802  */
1803 int virFileGetMountSubtree(const char *mtabpath,
1804                            const char *prefix,
1805                            char ***mountsret,
1806                            size_t *nmountsret)
1807 {
1808     return virFileGetMountSubtreeImpl(mtabpath, prefix, mountsret, nmountsret, false);
1809 }
1810
1811 /**
1812  * virFileGetMountReverseSubtree:
1813  * @mtabpath: mount file to parser (eg /proc/mounts)
1814  * @prefix: mount path prefix to match
1815  * @mountsret: allocated and filled with matching mounts
1816  * @nmountsret: filled with number of matching mounts, not counting NULL terminator
1817  *
1818  * Return the list of mounts from @mtabpath which contain
1819  * the path @prefix, sorted from longest to shortest path.
1820  * ie opposite order to which they appear in @mtabpath
1821  *
1822  * The @mountsret array will be NULL terminated and should
1823  * be freed with virStringFreeList
1824  *
1825  * Returns 0 on success, -1 on error
1826  */
1827 int virFileGetMountReverseSubtree(const char *mtabpath,
1828                                   const char *prefix,
1829                                   char ***mountsret,
1830                                   size_t *nmountsret)
1831 {
1832     return virFileGetMountSubtreeImpl(mtabpath, prefix, mountsret, nmountsret, true);
1833 }
1834
1835 #ifndef WIN32
1836 /* Check that a file is accessible under certain
1837  * user & gid.
1838  * @mode can be F_OK, or a bitwise combination of R_OK, W_OK, and X_OK.
1839  * see 'man access' for more details.
1840  * Returns 0 on success, -1 on fail with errno set.
1841  */
1842 int
1843 virFileAccessibleAs(const char *path, int mode,
1844                     uid_t uid, gid_t gid)
1845 {
1846     pid_t pid = 0;
1847     int status, ret = 0;
1848     int forkRet = 0;
1849     gid_t *groups;
1850     int ngroups;
1851
1852     if (uid == geteuid() &&
1853         gid == getegid())
1854         return access(path, mode);
1855
1856     ngroups = virGetGroupList(uid, gid, &groups);
1857     if (ngroups < 0)
1858         return -1;
1859
1860     pid = virFork();
1861
1862     if (pid < 0) {
1863         VIR_FREE(groups);
1864         return -1;
1865     }
1866
1867     if (pid) { /* parent */
1868         VIR_FREE(groups);
1869         if (virProcessWait(pid, &status, false) < 0) {
1870             /* virProcessWait() already reported error */
1871             errno = EINTR;
1872             return -1;
1873         }
1874
1875         if (status) {
1876             errno = status;
1877             return -1;
1878         }
1879
1880         return 0;
1881     }
1882
1883     /* child.
1884      * Return positive value here. Parent
1885      * will change it to negative one. */
1886
1887     if (forkRet < 0) {
1888         ret = errno;
1889         goto childerror;
1890     }
1891
1892     if (virSetUIDGID(uid, gid, groups, ngroups) < 0) {
1893         ret = errno;
1894         goto childerror;
1895     }
1896
1897     if (access(path, mode) < 0)
1898         ret = errno;
1899
1900  childerror:
1901     if ((ret & 0xFF) != ret) {
1902         VIR_WARN("unable to pass desired return value %d", ret);
1903         ret = 0xFF;
1904     }
1905
1906     _exit(ret);
1907 }
1908
1909 /* virFileOpenForceOwnerMode() - an internal utility function called
1910  * only by virFileOpenAs().  Sets the owner and mode of the file
1911  * opened as "fd" if it's not correct AND the flags say it should be
1912  * forced. */
1913 static int
1914 virFileOpenForceOwnerMode(const char *path, int fd, mode_t mode,
1915                           uid_t uid, gid_t gid, unsigned int flags)
1916 {
1917     int ret = 0;
1918     struct stat st;
1919
1920     if (!(flags & (VIR_FILE_OPEN_FORCE_OWNER | VIR_FILE_OPEN_FORCE_MODE)))
1921         return 0;
1922
1923     if (fstat(fd, &st) == -1) {
1924         ret = -errno;
1925         virReportSystemError(errno, _("stat of '%s' failed"), path);
1926         return ret;
1927     }
1928     /* NB: uid:gid are never "-1" (default) at this point - the caller
1929      * has always changed -1 to the value of get[gu]id().
1930     */
1931     if ((flags & VIR_FILE_OPEN_FORCE_OWNER) &&
1932         ((st.st_uid != uid) || (st.st_gid != gid)) &&
1933         (fchown(fd, uid, gid) < 0)) {
1934         ret = -errno;
1935         virReportSystemError(errno,
1936                              _("cannot chown '%s' to (%u, %u)"),
1937                              path, (unsigned int) uid,
1938                              (unsigned int) gid);
1939         return ret;
1940     }
1941     if ((flags & VIR_FILE_OPEN_FORCE_MODE) &&
1942         ((mode & (S_IRWXU|S_IRWXG|S_IRWXO)) !=
1943          (st.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO))) &&
1944         (fchmod(fd, mode) < 0)) {
1945         ret = -errno;
1946         virReportSystemError(errno,
1947                              _("cannot set mode of '%s' to %04o"),
1948                              path, mode);
1949         return ret;
1950     }
1951     return ret;
1952 }
1953
1954 /* virFileOpenForked() - an internal utility function called only by
1955  * virFileOpenAs(). It forks, then the child does setuid+setgid to
1956  * given uid:gid and attempts to open the file, while the parent just
1957  * calls recvfd to get the open fd back from the child. returns the
1958  * fd, or -errno if there is an error. */
1959 static int
1960 virFileOpenForked(const char *path, int openflags, mode_t mode,
1961                   uid_t uid, gid_t gid, unsigned int flags)
1962 {
1963     pid_t pid;
1964     int waitret, status, ret = 0;
1965     int fd = -1;
1966     int pair[2] = { -1, -1 };
1967     gid_t *groups;
1968     int ngroups;
1969
1970     /* parent is running as root, but caller requested that the
1971      * file be opened as some other user and/or group). The
1972      * following dance avoids problems caused by root-squashing
1973      * NFS servers. */
1974
1975     ngroups = virGetGroupList(uid, gid, &groups);
1976     if (ngroups < 0)
1977         return -errno;
1978
1979     if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair) < 0) {
1980         ret = -errno;
1981         virReportSystemError(errno,
1982                              _("failed to create socket needed for '%s'"),
1983                              path);
1984         VIR_FREE(groups);
1985         return ret;
1986     }
1987
1988     pid = virFork();
1989     if (pid < 0)
1990         return -errno;
1991
1992     if (pid == 0) {
1993
1994         /* child */
1995
1996         /* set desired uid/gid, then attempt to create the file */
1997         VIR_FORCE_CLOSE(pair[0]);
1998         if (virSetUIDGID(uid, gid, groups, ngroups) < 0) {
1999             ret = -errno;
2000             goto childerror;
2001         }
2002
2003         if ((fd = open(path, openflags, mode)) < 0) {
2004             ret = -errno;
2005             virReportSystemError(errno,
2006                                  _("child process failed to create file '%s'"),
2007                                  path);
2008             goto childerror;
2009         }
2010
2011         /* File is successfully open. Set permissions if requested. */
2012         ret = virFileOpenForceOwnerMode(path, fd, mode, uid, gid, flags);
2013         if (ret < 0)
2014             goto childerror;
2015
2016         do {
2017             ret = sendfd(pair[1], fd);
2018         } while (ret < 0 && errno == EINTR);
2019
2020         if (ret < 0) {
2021             ret = -errno;
2022             virReportSystemError(errno, "%s",
2023                                  _("child process failed to send fd to parent"));
2024             goto childerror;
2025         }
2026
2027     childerror:
2028         /* ret tracks -errno on failure, but exit value must be positive.
2029          * If the child exits with EACCES, then the parent tries again.  */
2030         /* XXX This makes assumptions about errno being < 255, which is
2031          * not true on Hurd.  */
2032         VIR_FORCE_CLOSE(pair[1]);
2033         if (ret < 0) {
2034             VIR_FORCE_CLOSE(fd);
2035         }
2036         ret = -ret;
2037         if ((ret & 0xff) != ret) {
2038             VIR_WARN("unable to pass desired return value %d", ret);
2039             ret = 0xff;
2040         }
2041         _exit(ret);
2042     }
2043
2044     /* parent */
2045
2046     VIR_FREE(groups);
2047     VIR_FORCE_CLOSE(pair[1]);
2048
2049     do {
2050         fd = recvfd(pair[0], 0);
2051     } while (fd < 0 && errno == EINTR);
2052     VIR_FORCE_CLOSE(pair[0]); /* NB: this preserves errno */
2053
2054     if (fd < 0 && errno != EACCES) {
2055         ret = -errno;
2056         while (waitpid(pid, NULL, 0) == -1 && errno == EINTR);
2057         return ret;
2058     }
2059
2060     /* wait for child to complete, and retrieve its exit code */
2061     while ((waitret = waitpid(pid, &status, 0) == -1)
2062            && (errno == EINTR));
2063     if (waitret == -1) {
2064         ret = -errno;
2065         virReportSystemError(errno,
2066                              _("failed to wait for child creating '%s'"),
2067                              path);
2068         VIR_FORCE_CLOSE(fd);
2069         return ret;
2070     }
2071     if (!WIFEXITED(status) || (ret = -WEXITSTATUS(status)) == -EACCES ||
2072         fd == -1) {
2073         /* fall back to the simpler method, which works better in
2074          * some cases */
2075         VIR_FORCE_CLOSE(fd);
2076         if (flags & VIR_FILE_OPEN_NOFORK) {
2077             /* If we had already tried opening w/o fork+setuid and
2078              * failed, no sense trying again. Just set return the
2079              * original errno that we got at that time (by
2080              * definition, always either EACCES or EPERM - EACCES
2081              * is close enough).
2082              */
2083             return -EACCES;
2084         }
2085         if ((fd = open(path, openflags, mode)) < 0)
2086             return -errno;
2087         ret = virFileOpenForceOwnerMode(path, fd, mode, uid, gid, flags);
2088         if (ret < 0) {
2089             VIR_FORCE_CLOSE(fd);
2090             return ret;
2091         }
2092     }
2093     return fd;
2094 }
2095
2096 /**
2097  * virFileOpenAs:
2098  * @path: file to open or create
2099  * @openflags: flags to pass to open
2100  * @mode: mode to use on creation or when forcing permissions
2101  * @uid: uid that should own file on creation
2102  * @gid: gid that should own file
2103  * @flags: bit-wise or of VIR_FILE_OPEN_* flags
2104  *
2105  * Open @path, and return an fd to the open file. @openflags contains
2106  * the flags normally passed to open(2), while those in @flags are
2107  * used internally. If @flags includes VIR_FILE_OPEN_NOFORK, then try
2108  * opening the file while executing with the current uid:gid
2109  * (i.e. don't fork+setuid+setgid before the call to open()).  If
2110  * @flags includes VIR_FILE_OPEN_FORK, then try opening the file while
2111  * the effective user id is @uid (by forking a child process); this
2112  * allows one to bypass root-squashing NFS issues; NOFORK is always
2113  * tried before FORK (the absence of both flags is treated identically
2114  * to (VIR_FILE_OPEN_NOFORK | VIR_FILE_OPEN_FORK)). If @flags includes
2115  * VIR_FILE_OPEN_FORCE_OWNER, then ensure that @path is owned by
2116  * uid:gid before returning (even if it already existed with a
2117  * different owner). If @flags includes VIR_FILE_OPEN_FORCE_MODE,
2118  * ensure it has those permissions before returning (again, even if
2119  * the file already existed with different permissions).
2120  *
2121  * The return value (if non-negative) is the file descriptor, left
2122  * open.  Returns -errno on failure.
2123  */
2124 int
2125 virFileOpenAs(const char *path, int openflags, mode_t mode,
2126               uid_t uid, gid_t gid, unsigned int flags)
2127 {
2128     int ret = 0, fd = -1;
2129
2130     /* allow using -1 to mean "current value" */
2131     if (uid == (uid_t) -1)
2132         uid = geteuid();
2133     if (gid == (gid_t) -1)
2134         gid = getegid();
2135
2136     /* treat absence of both flags as presence of both for simpler
2137      * calling. */
2138     if (!(flags & (VIR_FILE_OPEN_NOFORK|VIR_FILE_OPEN_FORK)))
2139         flags |= VIR_FILE_OPEN_NOFORK|VIR_FILE_OPEN_FORK;
2140
2141     if ((flags & VIR_FILE_OPEN_NOFORK)
2142         || (geteuid() != 0)
2143         || ((uid == 0) && (gid == 0))) {
2144
2145         if ((fd = open(path, openflags, mode)) < 0) {
2146             ret = -errno;
2147             if (!(flags & VIR_FILE_OPEN_FORK))
2148                 goto error;
2149         } else {
2150             ret = virFileOpenForceOwnerMode(path, fd, mode, uid, gid, flags);
2151             if (ret < 0)
2152                 goto error;
2153         }
2154     }
2155
2156     /* If we either 1) didn't try opening as current user at all, or
2157      * 2) failed, and errno/virStorageFileIsSharedFS indicate we might
2158      * be successful if we try as a different uid, then try doing
2159      * fork+setuid+setgid before opening.
2160      */
2161     if ((fd < 0) && (flags & VIR_FILE_OPEN_FORK)) {
2162
2163         if (ret < 0) {
2164             /* An open(2) that failed due to insufficient permissions
2165              * could return one or the other of these depending on OS
2166              * version and circumstances. Any other errno indicates a
2167              * problem that couldn't be remedied by fork+setuid
2168              * anyway. */
2169             if (ret != -EACCES && ret != -EPERM)
2170                 goto error;
2171
2172             /* On Linux we can also verify the FS-type of the
2173              * directory.  (this is a NOP on other platforms). */
2174             if (virFileIsSharedFS(path) <= 0)
2175                 goto error;
2176         }
2177
2178         /* passed all prerequisites - retry the open w/fork+setuid */
2179         if ((fd = virFileOpenForked(path, openflags, mode, uid, gid, flags)) < 0) {
2180             ret = fd;
2181             goto error;
2182         }
2183     }
2184
2185     /* File is successfully opened */
2186     return fd;
2187
2188  error:
2189     if (fd >= 0) {
2190         /* some other failure after the open succeeded */
2191         VIR_FORCE_CLOSE(fd);
2192     }
2193     /* whoever failed the open last has already set ret = -errno */
2194     return ret;
2195 }
2196
2197 /* return -errno on failure, or 0 on success */
2198 static int
2199 virDirCreateNoFork(const char *path,
2200                    mode_t mode, uid_t uid, gid_t gid,
2201                    unsigned int flags)
2202 {
2203     int ret = 0;
2204     struct stat st;
2205
2206     if ((mkdir(path, mode) < 0)
2207         && !((errno == EEXIST) && (flags & VIR_DIR_CREATE_ALLOW_EXIST))) {
2208         ret = -errno;
2209         virReportSystemError(errno, _("failed to create directory '%s'"),
2210                              path);
2211         goto error;
2212     }
2213
2214     if (stat(path, &st) == -1) {
2215         ret = -errno;
2216         virReportSystemError(errno, _("stat of '%s' failed"), path);
2217         goto error;
2218     }
2219     if (((st.st_uid != uid) || (st.st_gid != gid))
2220         && (chown(path, uid, gid) < 0)) {
2221         ret = -errno;
2222         virReportSystemError(errno, _("cannot chown '%s' to (%u, %u)"),
2223                              path, (unsigned int) uid, (unsigned int) gid);
2224         goto error;
2225     }
2226     if ((flags & VIR_DIR_CREATE_FORCE_PERMS)
2227         && (chmod(path, mode) < 0)) {
2228         ret = -errno;
2229         virReportSystemError(errno,
2230                              _("cannot set mode of '%s' to %04o"),
2231                              path, mode);
2232         goto error;
2233     }
2234  error:
2235     return ret;
2236 }
2237
2238 /* return -errno on failure, or 0 on success */
2239 int
2240 virDirCreate(const char *path,
2241              mode_t mode, uid_t uid, gid_t gid,
2242              unsigned int flags)
2243 {
2244     struct stat st;
2245     pid_t pid;
2246     int waitret;
2247     int status, ret = 0;
2248     gid_t *groups;
2249     int ngroups;
2250
2251     /* allow using -1 to mean "current value" */
2252     if (uid == (uid_t) -1)
2253         uid = geteuid();
2254     if (gid == (gid_t) -1)
2255         gid = getegid();
2256
2257     if ((!(flags & VIR_DIR_CREATE_AS_UID))
2258         || (geteuid() != 0)
2259         || ((uid == 0) && (gid == 0))
2260         || ((flags & VIR_DIR_CREATE_ALLOW_EXIST) && (stat(path, &st) >= 0))) {
2261         return virDirCreateNoFork(path, mode, uid, gid, flags);
2262     }
2263
2264     ngroups = virGetGroupList(uid, gid, &groups);
2265     if (ngroups < 0)
2266         return -errno;
2267
2268     pid = virFork();
2269
2270     if (pid < 0) {
2271         ret = -errno;
2272         VIR_FREE(groups);
2273         return ret;
2274     }
2275
2276     if (pid) { /* parent */
2277         /* wait for child to complete, and retrieve its exit code */
2278         VIR_FREE(groups);
2279         while ((waitret = waitpid(pid, &status, 0) == -1)  && (errno == EINTR));
2280         if (waitret == -1) {
2281             ret = -errno;
2282             virReportSystemError(errno,
2283                                  _("failed to wait for child creating '%s'"),
2284                                  path);
2285             goto parenterror;
2286         }
2287         if (!WIFEXITED(status) || (ret = -WEXITSTATUS(status)) == -EACCES) {
2288             /* fall back to the simpler method, which works better in
2289              * some cases */
2290             return virDirCreateNoFork(path, mode, uid, gid, flags);
2291         }
2292  parenterror:
2293         return ret;
2294     }
2295
2296     /* child */
2297
2298     /* set desired uid/gid, then attempt to create the directory */
2299     if (virSetUIDGID(uid, gid, groups, ngroups) < 0) {
2300         ret = -errno;
2301         goto childerror;
2302     }
2303     if (mkdir(path, mode) < 0) {
2304         ret = -errno;
2305         if (ret != -EACCES) {
2306             /* in case of EACCES, the parent will retry */
2307             virReportSystemError(errno, _("child failed to create directory '%s'"),
2308                                  path);
2309         }
2310         goto childerror;
2311     }
2312     /* check if group was set properly by creating after
2313      * setgid. If not, try doing it with chown */
2314     if (stat(path, &st) == -1) {
2315         ret = -errno;
2316         virReportSystemError(errno,
2317                              _("stat of '%s' failed"), path);
2318         goto childerror;
2319     }
2320     if ((st.st_gid != gid) && (chown(path, (uid_t) -1, gid) < 0)) {
2321         ret = -errno;
2322         virReportSystemError(errno,
2323                              _("cannot chown '%s' to group %u"),
2324                              path, (unsigned int) gid);
2325         goto childerror;
2326     }
2327     if ((flags & VIR_DIR_CREATE_FORCE_PERMS)
2328         && chmod(path, mode) < 0) {
2329         virReportSystemError(errno,
2330                              _("cannot set mode of '%s' to %04o"),
2331                              path, mode);
2332         goto childerror;
2333     }
2334  childerror:
2335     _exit(ret);
2336 }
2337
2338 #else /* WIN32 */
2339
2340 int
2341 virFileAccessibleAs(const char *path,
2342                     int mode,
2343                     uid_t uid ATTRIBUTE_UNUSED,
2344                     gid_t gid ATTRIBUTE_UNUSED)
2345 {
2346
2347     VIR_WARN("Ignoring uid/gid due to WIN32");
2348
2349     return access(path, mode);
2350 }
2351
2352 /* return -errno on failure, or 0 on success */
2353 int
2354 virFileOpenAs(const char *path ATTRIBUTE_UNUSED,
2355               int openflags ATTRIBUTE_UNUSED,
2356               mode_t mode ATTRIBUTE_UNUSED,
2357               uid_t uid ATTRIBUTE_UNUSED,
2358               gid_t gid ATTRIBUTE_UNUSED,
2359               unsigned int flags_unused ATTRIBUTE_UNUSED)
2360 {
2361     virReportError(VIR_ERR_INTERNAL_ERROR,
2362                    "%s", _("virFileOpenAs is not implemented for WIN32"));
2363
2364     return -ENOSYS;
2365 }
2366
2367 int
2368 virDirCreate(const char *path ATTRIBUTE_UNUSED,
2369              mode_t mode ATTRIBUTE_UNUSED,
2370              uid_t uid ATTRIBUTE_UNUSED,
2371              gid_t gid ATTRIBUTE_UNUSED,
2372              unsigned int flags_unused ATTRIBUTE_UNUSED)
2373 {
2374     virReportError(VIR_ERR_INTERNAL_ERROR,
2375                    "%s", _("virDirCreate is not implemented for WIN32"));
2376
2377     return -ENOSYS;
2378 }
2379 #endif /* WIN32 */
2380
2381 /**
2382  * virDirRead:
2383  * @dirp: directory to read
2384  * @end: output one entry
2385  * @name: if non-NULL, the name related to @dirp for use in error reporting
2386  *
2387  * Wrapper around readdir. Typical usage:
2388  *   struct dirent ent;
2389  *   int value;
2390  *   DIR *dir;
2391  *   if (!(dir = opendir(name)))
2392  *       goto error;
2393  *   while ((value = virDirRead(dir, &ent, name)) > 0)
2394  *       process ent;
2395  *   if (value < 0)
2396  *       goto error;
2397  *
2398  * Returns -1 on error, with error already reported if @name was
2399  * supplied.  On success, returns 1 for entry read, 0 for end-of-dir.
2400  */
2401 int virDirRead(DIR *dirp, struct dirent **ent, const char *name)
2402 {
2403     errno = 0;
2404     *ent = readdir(dirp); /* exempt from syntax-check */
2405     if (!*ent && errno) {
2406         if (name)
2407             virReportSystemError(errno, _("Unable to read directory '%s'"),
2408                                  name);
2409         return -1;
2410     }
2411     return !!*ent;
2412 }
2413
2414 static int
2415 virFileMakePathHelper(char *path, mode_t mode)
2416 {
2417     struct stat st;
2418     char *p;
2419
2420     VIR_DEBUG("path=%s mode=0%o", path, mode);
2421
2422     if (stat(path, &st) >= 0) {
2423         if (S_ISDIR(st.st_mode))
2424             return 0;
2425
2426         errno = ENOTDIR;
2427         return -1;
2428     }
2429
2430     if (errno != ENOENT)
2431         return -1;
2432
2433     if ((p = strrchr(path, '/')) == NULL) {
2434         errno = EINVAL;
2435         return -1;
2436     }
2437
2438     if (p != path) {
2439         *p = '\0';
2440
2441         if (virFileMakePathHelper(path, mode) < 0)
2442             return -1;
2443
2444         *p = '/';
2445     }
2446
2447     if (mkdir(path, mode) < 0 && errno != EEXIST)
2448         return -1;
2449
2450     return 0;
2451 }
2452
2453 /**
2454  * Creates the given directory with mode 0777 if it's not already existing.
2455  *
2456  * Returns 0 on success, or -1 if an error occurred (in which case, errno
2457  * is set appropriately).
2458  */
2459 int
2460 virFileMakePath(const char *path)
2461 {
2462     return virFileMakePathWithMode(path, 0777);
2463 }
2464
2465 int
2466 virFileMakePathWithMode(const char *path,
2467                         mode_t mode)
2468 {
2469     int ret = -1;
2470     char *tmp;
2471
2472     if (VIR_STRDUP(tmp, path) < 0) {
2473         errno = ENOMEM;
2474         goto cleanup;
2475     }
2476
2477     ret = virFileMakePathHelper(tmp, mode);
2478
2479  cleanup:
2480     VIR_FREE(tmp);
2481     return ret;
2482 }
2483
2484
2485 int
2486 virFileMakeParentPath(const char *path)
2487 {
2488     char *p;
2489     char *tmp;
2490     int ret = -1;
2491
2492     VIR_DEBUG("path=%s", path);
2493
2494     if (VIR_STRDUP(tmp, path) < 0) {
2495         errno = ENOMEM;
2496         return -1;
2497     }
2498
2499     if ((p = strrchr(tmp, '/')) == NULL) {
2500         errno = EINVAL;
2501         goto cleanup;
2502     }
2503     *p = '\0';
2504
2505     ret = virFileMakePathHelper(tmp, 0777);
2506
2507  cleanup:
2508     VIR_FREE(tmp);
2509     return ret;
2510 }
2511
2512
2513 /* Build up a fully qualified path for a config file to be
2514  * associated with a persistent guest or network */
2515 char *
2516 virFileBuildPath(const char *dir, const char *name, const char *ext)
2517 {
2518     char *path;
2519
2520     if (ext == NULL) {
2521         ignore_value(virAsprintf(&path, "%s/%s", dir, name));
2522     } else {
2523         ignore_value(virAsprintf(&path, "%s/%s%s", dir, name, ext));
2524     }
2525
2526     return path;
2527 }
2528
2529 /* Open a non-blocking master side of a pty.  If ttyName is not NULL,
2530  * then populate it with the name of the slave.  If rawmode is set,
2531  * also put the master side into raw mode before returning.  */
2532 #ifndef WIN32
2533 int
2534 virFileOpenTty(int *ttymaster, char **ttyName, int rawmode)
2535 {
2536     /* XXX A word of caution - on some platforms (Solaris and HP-UX),
2537      * additional ioctl() calls are needs after opening the slave
2538      * before it will cause isatty() to return true.  Should we make
2539      * virFileOpenTty also return the opened slave fd, so the caller
2540      * doesn't have to worry about that mess?  */
2541     int ret = -1;
2542     int slave = -1;
2543     char *name = NULL;
2544
2545     /* Unfortunately, we can't use the name argument of openpty, since
2546      * there is no guarantee on how large the buffer has to be.
2547      * Likewise, we can't use the termios argument: we have to use
2548      * read-modify-write since there is no portable way to initialize
2549      * a struct termios without use of tcgetattr.  */
2550     if (openpty(ttymaster, &slave, NULL, NULL, NULL) < 0)
2551         return -1;
2552
2553     /* What a shame that openpty cannot atomically set FD_CLOEXEC, but
2554      * that using posix_openpt/grantpt/unlockpt/ptsname is not
2555      * thread-safe, and that ptsname_r is not portable.  */
2556     if (virSetNonBlock(*ttymaster) < 0 ||
2557         virSetCloseExec(*ttymaster) < 0)
2558         goto cleanup;
2559
2560     /* While Linux supports tcgetattr on either the master or the
2561      * slave, Solaris requires it to be on the slave.  */
2562     if (rawmode) {
2563         struct termios ttyAttr;
2564         if (tcgetattr(slave, &ttyAttr) < 0)
2565             goto cleanup;
2566
2567         cfmakeraw(&ttyAttr);
2568
2569         if (tcsetattr(slave, TCSADRAIN, &ttyAttr) < 0)
2570             goto cleanup;
2571     }
2572
2573     /* ttyname_r on the slave is required by POSIX, while ptsname_r on
2574      * the master is a glibc extension, and the POSIX ptsname is not
2575      * thread-safe.  Since openpty gave us both descriptors, guess
2576      * which way we will determine the name?  :)  */
2577     if (ttyName) {
2578         /* Initial guess of 64 is generally sufficient; rely on ERANGE
2579          * to tell us if we need to grow.  */
2580         size_t len = 64;
2581         int rc;
2582
2583         if (VIR_ALLOC_N(name, len) < 0)
2584             goto cleanup;
2585
2586         while ((rc = ttyname_r(slave, name, len)) == ERANGE) {
2587             if (VIR_RESIZE_N(name, len, len, len) < 0)
2588                 goto cleanup;
2589         }
2590         if (rc != 0) {
2591             errno = rc;
2592             goto cleanup;
2593         }
2594         *ttyName = name;
2595         name = NULL;
2596     }
2597
2598     ret = 0;
2599
2600  cleanup:
2601     if (ret != 0)
2602         VIR_FORCE_CLOSE(*ttymaster);
2603     VIR_FORCE_CLOSE(slave);
2604     VIR_FREE(name);
2605
2606     return ret;
2607 }
2608 #else /* WIN32 */
2609 int
2610 virFileOpenTty(int *ttymaster ATTRIBUTE_UNUSED,
2611                char **ttyName ATTRIBUTE_UNUSED,
2612                int rawmode ATTRIBUTE_UNUSED)
2613 {
2614     /* mingw completely lacks pseudo-terminals, and the gnulib
2615      * replacements are not (yet) license compatible.  */
2616     errno = ENOSYS;
2617     return -1;
2618 }
2619 #endif /* WIN32 */
2620
2621 bool
2622 virFileIsAbsPath(const char *path)
2623 {
2624     if (!path)
2625         return false;
2626
2627     if (VIR_FILE_IS_DIR_SEPARATOR(path[0]))
2628         return true;
2629
2630 #ifdef WIN32
2631     if (c_isalpha(path[0]) &&
2632         path[1] == ':' &&
2633         VIR_FILE_IS_DIR_SEPARATOR(path[2]))
2634         return true;
2635 #endif
2636
2637     return false;
2638 }
2639
2640
2641 const char *
2642 virFileSkipRoot(const char *path)
2643 {
2644 #ifdef WIN32
2645     /* Skip \\server\share or //server/share */
2646     if (VIR_FILE_IS_DIR_SEPARATOR(path[0]) &&
2647         VIR_FILE_IS_DIR_SEPARATOR(path[1]) &&
2648         path[2] &&
2649         !VIR_FILE_IS_DIR_SEPARATOR(path[2]))
2650     {
2651         const char *p = strchr(path + 2, VIR_FILE_DIR_SEPARATOR);
2652         const char *q = strchr(path + 2, '/');
2653
2654         if (p == NULL || (q != NULL && q < p))
2655             p = q;
2656
2657         if (p && p > path + 2 && p[1]) {
2658             path = p + 1;
2659
2660             while (path[0] &&
2661                    !VIR_FILE_IS_DIR_SEPARATOR(path[0]))
2662                 path++;
2663
2664             /* Possibly skip a backslash after the share name */
2665             if (VIR_FILE_IS_DIR_SEPARATOR(path[0]))
2666                 path++;
2667
2668             return path;
2669         }
2670     }
2671 #endif
2672
2673     /* Skip initial slashes */
2674     if (VIR_FILE_IS_DIR_SEPARATOR(path[0])) {
2675         while (VIR_FILE_IS_DIR_SEPARATOR(path[0]))
2676             path++;
2677
2678         return path;
2679     }
2680
2681 #ifdef WIN32
2682     /* Skip X:\ */
2683     if (c_isalpha(path[0]) &&
2684         path[1] == ':' &&
2685         VIR_FILE_IS_DIR_SEPARATOR(path[2]))
2686         return path + 3;
2687 #endif
2688
2689     return path;
2690 }
2691
2692
2693
2694 /*
2695  * Creates an absolute path for a potentially relative path.
2696  * Return 0 if the path was not relative, or on success.
2697  * Return -1 on error.
2698  *
2699  * You must free the result.
2700  */
2701 int
2702 virFileAbsPath(const char *path, char **abspath)
2703 {
2704     char *buf;
2705
2706     if (path[0] == '/') {
2707         if (VIR_STRDUP(*abspath, path) < 0)
2708             return -1;
2709     } else {
2710         buf = getcwd(NULL, 0);
2711         if (buf == NULL)
2712             return -1;
2713
2714         if (virAsprintf(abspath, "%s/%s", buf, path) < 0) {
2715             VIR_FREE(buf);
2716             return -1;
2717         }
2718         VIR_FREE(buf);
2719     }
2720
2721     return 0;
2722 }
2723
2724 /* Remove spurious / characters from a path. The result must be freed */
2725 char *
2726 virFileSanitizePath(const char *path)
2727 {
2728     const char *cur = path;
2729     char *cleanpath;
2730     int idx = 0;
2731
2732     if (VIR_STRDUP(cleanpath, path) < 0)
2733         return NULL;
2734
2735     /* Need to sanitize:
2736      * //           -> //
2737      * ///          -> /
2738      * /../foo      -> /../foo
2739      * /foo///bar/  -> /foo/bar
2740      */
2741
2742     /* Starting with // is valid posix, but ///foo == /foo */
2743     if (cur[0] == '/' && cur[1] == '/' && cur[2] != '/') {
2744         idx = 2;
2745         cur += 2;
2746     }
2747
2748     /* Sanitize path in place */
2749     while (*cur != '\0') {
2750         if (*cur != '/') {
2751             cleanpath[idx++] = *cur++;
2752             continue;
2753         }
2754
2755         /* Skip all extra / */
2756         while (*++cur == '/')
2757             continue;
2758
2759         /* Don't add a trailing / */
2760         if (idx != 0 && *cur == '\0')
2761             break;
2762
2763         cleanpath[idx++] = '/';
2764     }
2765     cleanpath[idx] = '\0';
2766
2767     return cleanpath;
2768 }
2769
2770
2771 /**
2772  * virFilePrintf:
2773  *
2774  * A replacement for fprintf() which uses virVasprintf to
2775  * ensure that portable string format placeholders can be
2776  * used, since gnulib's fprintf() replacement is not
2777  * LGPLV2+ compatible
2778  */
2779 int virFilePrintf(FILE *fp, const char *msg, ...)
2780 {
2781     va_list vargs;
2782     char *str;
2783     int ret;
2784
2785     va_start(vargs, msg);
2786
2787     if ((ret = virVasprintf(&str, msg, vargs)) < 0)
2788         goto cleanup;
2789
2790     if (fwrite(str, 1, ret, fp) != ret) {
2791         virReportSystemError(errno, "%s",
2792                              _("Could not write to stream"));
2793         ret = -1;
2794     }
2795
2796     VIR_FREE(str);
2797
2798  cleanup:
2799     va_end(vargs);
2800
2801     return ret;
2802 }
2803
2804
2805 #ifdef __linux__
2806
2807 # ifndef NFS_SUPER_MAGIC
2808 #  define NFS_SUPER_MAGIC 0x6969
2809 # endif
2810 # ifndef OCFS2_SUPER_MAGIC
2811 #  define OCFS2_SUPER_MAGIC 0x7461636f
2812 # endif
2813 # ifndef GFS2_MAGIC
2814 #  define GFS2_MAGIC 0x01161970
2815 # endif
2816 # ifndef AFS_FS_MAGIC
2817 #  define AFS_FS_MAGIC 0x6B414653
2818 # endif
2819 # ifndef SMB_SUPER_MAGIC
2820 #  define SMB_SUPER_MAGIC 0x517B
2821 # endif
2822 # ifndef CIFS_SUPER_MAGIC
2823 #  define CIFS_SUPER_MAGIC 0xFF534D42
2824 # endif
2825
2826 int
2827 virFileIsSharedFSType(const char *path,
2828                       int fstypes)
2829 {
2830     char *dirpath, *p;
2831     struct statfs sb;
2832     int statfs_ret;
2833
2834     if (VIR_STRDUP(dirpath, path) < 0)
2835         return -1;
2836
2837     do {
2838
2839         /* Try less and less of the path until we get to a
2840          * directory we can stat. Even if we don't have 'x'
2841          * permission on any directory in the path on the NFS
2842          * server (assuming it's NFS), we will be able to stat the
2843          * mount point, and that will properly tell us if the
2844          * fstype is NFS.
2845          */
2846
2847         if ((p = strrchr(dirpath, '/')) == NULL) {
2848             virReportSystemError(EINVAL,
2849                          _("Invalid relative path '%s'"), path);
2850             VIR_FREE(dirpath);
2851             return -1;
2852         }
2853
2854         if (p == dirpath)
2855             *(p+1) = '\0';
2856         else
2857             *p = '\0';
2858
2859         statfs_ret = statfs(dirpath, &sb);
2860
2861     } while ((statfs_ret < 0) && (p != dirpath));
2862
2863     VIR_FREE(dirpath);
2864
2865     if (statfs_ret < 0) {
2866         virReportSystemError(errno,
2867                              _("cannot determine filesystem for '%s'"),
2868                              path);
2869         return -1;
2870     }
2871
2872     VIR_DEBUG("Check if path %s with FS magic %lld is shared",
2873               path, (long long int)sb.f_type);
2874
2875     if ((fstypes & VIR_FILE_SHFS_NFS) &&
2876         (sb.f_type == NFS_SUPER_MAGIC))
2877         return 1;
2878
2879     if ((fstypes & VIR_FILE_SHFS_GFS2) &&
2880         (sb.f_type == GFS2_MAGIC))
2881         return 1;
2882     if ((fstypes & VIR_FILE_SHFS_OCFS) &&
2883         (sb.f_type == OCFS2_SUPER_MAGIC))
2884         return 1;
2885     if ((fstypes & VIR_FILE_SHFS_AFS) &&
2886         (sb.f_type == AFS_FS_MAGIC))
2887         return 1;
2888     if ((fstypes & VIR_FILE_SHFS_SMB) &&
2889         (sb.f_type == SMB_SUPER_MAGIC))
2890         return 1;
2891     if ((fstypes & VIR_FILE_SHFS_CIFS) &&
2892         (sb.f_type == CIFS_SUPER_MAGIC))
2893         return 1;
2894
2895     return 0;
2896 }
2897 #else
2898 int virFileIsSharedFSType(const char *path ATTRIBUTE_UNUSED,
2899                           int fstypes ATTRIBUTE_UNUSED)
2900 {
2901     /* XXX implement me :-) */
2902     return 0;
2903 }
2904 #endif
2905
2906 int virFileIsSharedFS(const char *path)
2907 {
2908     return virFileIsSharedFSType(path,
2909                                  VIR_FILE_SHFS_NFS |
2910                                  VIR_FILE_SHFS_GFS2 |
2911                                  VIR_FILE_SHFS_OCFS |
2912                                  VIR_FILE_SHFS_AFS |
2913                                  VIR_FILE_SHFS_SMB |
2914                                  VIR_FILE_SHFS_CIFS);
2915 }