appliance: Use qemu -machine option where available (RHBZ#700369).
[libguestfs.git] / src / appliance.c
1 /* libguestfs
2  * Copyright (C) 2010-2011 Red Hat Inc.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library 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 GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #include <config.h>
20
21 #include <errno.h>
22 #include <dirent.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <unistd.h>
27 #include <string.h>
28 #include <fcntl.h>
29 #include <time.h>
30 #include <sys/stat.h>
31 #include <sys/select.h>
32 #include <sys/wait.h>
33 #include <utime.h>
34
35 #ifdef HAVE_SYS_TYPES_H
36 #include <sys/types.h>
37 #endif
38
39 #include "guestfs.h"
40 #include "guestfs-internal.h"
41 #include "guestfs-internal-actions.h"
42 #include "guestfs_protocol.h"
43
44 /* Old-style appliance is going to be obsoleted. */
45 static const char *kernel_name = "vmlinuz." host_cpu;
46 static const char *initrd_name = "initramfs." host_cpu ".img";
47
48 static int find_path (guestfs_h *g, int (*pred) (guestfs_h *g, const char *pelem, void *data), void *data, char **pelem);
49 static int dir_contains_file (const char *dir, const char *file);
50 static int dir_contains_files (const char *dir, ...);
51 static int contains_ordinary_appliance (guestfs_h *g, const char *path, void *data);
52 static int contains_supermin_appliance (guestfs_h *g, const char *path, void *data);
53 static char *calculate_supermin_checksum (guestfs_h *g, const char *supermin_path);
54 static int check_for_cached_appliance (guestfs_h *g, const char *supermin_path, const char *checksum, uid_t uid, char **kernel, char **initrd, char **appliance);
55 static int build_supermin_appliance (guestfs_h *g, const char *supermin_path, const char *checksum, uid_t uid, char **kernel, char **initrd, char **appliance);
56 static int hard_link_to_cached_appliance (guestfs_h *g, const char *cachedir, char **kernel, char **initrd, char **appliance);
57 static int run_supermin_helper (guestfs_h *g, const char *supermin_path, const char *cachedir, size_t cdlen);
58
59 /* Locate or build the appliance.
60  *
61  * This function locates or builds the appliance as necessary,
62  * handling the supermin appliance, caching of supermin-built
63  * appliances, or using an ordinary appliance.
64  *
65  * The return value is 0 = good, -1 = error.  Returned in '*kernel'
66  * will be the name of the kernel to use, '*initrd' the name of the
67  * initrd, '*appliance' the name of the ext2 root filesystem.
68  * '*appliance' can be NULL, meaning that we are using an ordinary
69  * (non-ext2) appliance.  All three strings must be freed by the
70  * caller.  However the referenced files themselves must not be
71  * deleted.
72  *
73  * The process is as follows:
74  *
75  * (1) Look for the first element of g->path which contains a
76  * supermin appliance skeleton.  If no element has this, skip
77  * straight to step (5).
78  *
79  * (2) Calculate the checksum of this supermin appliance.
80  *
81  * (3) Check whether a cached appliance with the checksum calculated
82  * in (2) exists and passes basic security checks.  If so, return
83  * this appliance.
84  *
85  * (4) Try to build the supermin appliance.  If this is successful,
86  * return it.
87  *
88  * (5) Check each element of g->path, looking for an ordinary appliance.
89  * If one is found, return it.
90  *
91  * The supermin appliance cache directory lives in
92  * $TMPDIR/.guestfs-$UID/ and consists of four files:
93  *
94  *   $TMPDIR/.guestfs-$UID/checksum       - the checksum
95  *   $TMPDIR/.guestfs-$UID/kernel         - symlink to the kernel
96  *   $TMPDIR/.guestfs-$UID/initrd         - the febootstrap initrd
97  *   $TMPDIR/.guestfs-$UID/root           - the appliance
98  *
99  * Since multiple instances of libguestfs with the same UID may be
100  * racing to create an appliance, we need to be careful when building
101  * and using the appliance.
102  *
103  * If a cached appliance with checksum exists (step (2) above) then we
104  * make a hard link to it with our current PID, so that we have a copy
105  * even if the appliance is replaced by another process building an
106  * appliance afterwards:
107  *
108  *   $TMPDIR/.guestfs-$UID/kernel.$PID
109  *   $TMPDIR/.guestfs-$UID/initrd.$PID
110  *   $TMPDIR/.guestfs-$UID/root.$PID
111  *
112  * A lock is taken on "checksum" while we perform the link.
113  *
114  * Linked files are deleted by a garbage collection sweep which can be
115  * initiated by any libguestfs process with the same UID when the
116  * corresponding PID no longer exists.  (This is safe: the parent is
117  * always around in guestfs_launch() while qemu is starting up, and
118  * after that qemu will either have finished with the files or be
119  * holding them open, so we can unlink them).
120  *
121  * When building a new appliance (step (3)), it is built into randomly
122  * named temporary files in the $TMPDIR.  Then a lock is acquired on
123  * $TMPDIR/.guestfs-$UID/checksum (this file being created if
124  * necessary), the files are renamed into their final location, and
125  * the lock is released.
126  */
127 int
128 guestfs___build_appliance (guestfs_h *g,
129                            char **kernel, char **initrd, char **appliance)
130 {
131   int r;
132   uid_t uid = geteuid ();
133
134   /* Step (1). */
135   char *supermin_path;
136   r = find_path (g, contains_supermin_appliance, NULL, &supermin_path);
137   if (r == -1)
138     return -1;
139
140   if (r == 1) {
141     /* Step (2): calculate checksum. */
142     char *checksum = calculate_supermin_checksum (g, supermin_path);
143     if (checksum) {
144       /* Step (3): cached appliance exists? */
145       r = check_for_cached_appliance (g, supermin_path, checksum, uid,
146                                       kernel, initrd, appliance);
147       if (r != 0) {
148         free (supermin_path);
149         free (checksum);
150         return r == 1 ? 0 : -1;
151       }
152
153       /* Step (4): build supermin appliance. */
154       r = build_supermin_appliance (g, supermin_path, checksum, uid,
155                                     kernel, initrd, appliance);
156       free (supermin_path);
157       free (checksum);
158       return r;
159     }
160     free (supermin_path);
161   }
162
163   /* Step (5). */
164   char *path;
165   r = find_path (g, contains_ordinary_appliance, NULL, &path);
166   if (r == -1)
167     return -1;
168
169   if (r == 1) {
170     size_t len = strlen (path);
171     *kernel = safe_malloc (g, len + strlen (kernel_name) + 2);
172     *initrd = safe_malloc (g, len + strlen (initrd_name) + 2);
173     sprintf (*kernel, "%s/%s", path, kernel_name);
174     sprintf (*initrd, "%s/%s", path, initrd_name);
175     *appliance = NULL;
176
177     free (path);
178     return 0;
179   }
180
181   error (g, _("cannot find any suitable libguestfs supermin or ordinary appliance on LIBGUESTFS_PATH (search path: %s)"),
182          g->path);
183   return -1;
184 }
185
186 static int
187 contains_ordinary_appliance (guestfs_h *g, const char *path, void *data)
188 {
189   return dir_contains_files (path, kernel_name, initrd_name, NULL);
190 }
191
192 static int
193 contains_supermin_appliance (guestfs_h *g, const char *path, void *data)
194 {
195   return dir_contains_files (path, "supermin.d", NULL);
196 }
197
198 /* supermin_path is a path which is known to contain a supermin
199  * appliance.  Using febootstrap-supermin-helper -f checksum calculate
200  * the checksum so we can see if it is cached.
201  */
202 static char *
203 calculate_supermin_checksum (guestfs_h *g, const char *supermin_path)
204 {
205   size_t len = 2 * strlen (supermin_path) + 256;
206   char cmd[len];
207   int pass_u_g_args = getuid () != geteuid () || getgid () != getegid ();
208
209   if (!pass_u_g_args)
210     snprintf (cmd, len,
211               "febootstrap-supermin-helper%s "
212               "-f checksum "
213               "'%s/supermin.d' "
214               host_cpu,
215               g->verbose ? " --verbose" : "",
216               supermin_path);
217   else
218     snprintf (cmd, len,
219               "febootstrap-supermin-helper%s "
220               "-u %i "
221               "-g %i "
222               "-f checksum "
223               "'%s/supermin.d' "
224               host_cpu,
225               g->verbose ? " --verbose" : "",
226               geteuid (), getegid (),
227               supermin_path);
228
229   if (g->verbose)
230     guestfs___print_timestamped_message (g, "%s", cmd);
231
232   /* Errors here are non-fatal, so we don't need to call error(). */
233   FILE *pp = popen (cmd, "r");
234   if (pp == NULL)
235     return NULL;
236
237   char checksum[256];
238   if (fgets (checksum, sizeof checksum, pp) == NULL) {
239     pclose (pp);
240     return NULL;
241   }
242
243   if (pclose (pp) == -1) {
244     warning (g, "pclose: %m");
245     return NULL;
246   }
247
248   len = strlen (checksum);
249
250   if (len < 16) {               /* sanity check */
251     warning (g, "febootstrap-supermin-helper -f checksum returned a short string");
252     return NULL;
253   }
254
255   if (len > 0 && checksum[len-1] == '\n')
256     checksum[--len] = '\0';
257
258   return safe_strndup (g, checksum, len);
259 }
260
261 static int
262 process_exists (int pid)
263 {
264   if (kill (pid, 0) == 0)
265     return 1;
266
267   if (errno == ESRCH)
268     return 0;
269
270   return -1;
271 }
272
273 /* Garbage collect appliance hard links.  Files that match
274  * (kernel|initrd|root).$PID where the corresponding PID doesn't exist
275  * are deleted.  Note that errors in this function don't matter.
276  * There may also be other libguestfs processes racing to do the same
277  * thing here.
278  */
279 static void
280 garbage_collect_appliances (const char *cachedir)
281 {
282   DIR *dir;
283   struct dirent *d;
284   int pid;
285
286   dir = opendir (cachedir);
287   if (dir == NULL)
288     return;
289
290   while ((d = readdir (dir)) != NULL) {
291     if (sscanf (d->d_name, "kernel.%d", &pid) == 1 &&
292         process_exists (pid) == 0)
293       unlinkat (dirfd (dir), d->d_name, 0);
294     else if (sscanf (d->d_name, "initrd.%d", &pid) == 1 &&
295              process_exists (pid) == 0)
296       unlinkat (dirfd (dir), d->d_name, 0);
297     else if (sscanf (d->d_name, "root.%d", &pid) == 1 &&
298              process_exists (pid) == 0)
299       unlinkat (dirfd (dir), d->d_name, 0);
300   }
301
302   closedir (dir);
303 }
304
305 static int
306 check_for_cached_appliance (guestfs_h *g,
307                             const char *supermin_path, const char *checksum,
308                             uid_t uid,
309                             char **kernel, char **initrd, char **appliance)
310 {
311   const char *tmpdir = guestfs___persistent_tmpdir ();
312
313   /* len must be longer than the length of any pathname we can
314    * generate in this function.
315    */
316   size_t len = strlen (tmpdir) + 128;
317   char cachedir[len];
318   snprintf (cachedir, len, "%s/.guestfs-%d", tmpdir, uid);
319   char filename[len];
320   snprintf (filename, len, "%s/checksum", cachedir);
321
322   (void) mkdir (cachedir, 0755);
323
324   /* See if the cache directory exists and passes some simple checks
325    * to make sure it has not been tampered with.
326    */
327   struct stat statbuf;
328   if (lstat (cachedir, &statbuf) == -1)
329     return 0;
330   if (statbuf.st_uid != uid) {
331     error (g, _("security: cached appliance %s is not owned by UID %d"),
332            filename, uid);
333     return -1;
334   }
335   if (!S_ISDIR (statbuf.st_mode)) {
336     error (g, _("security: cached appliance %s is not a directory (mode %o)"),
337            filename, statbuf.st_mode);
338     return -1;
339   }
340   if ((statbuf.st_mode & 0022) != 0) {
341     error (g, _("security: cached appliance %s is writable by group or other (mode %o)"),
342            cachedir, statbuf.st_mode);
343     return -1;
344   }
345
346   (void) utime (cachedir, NULL);
347
348   garbage_collect_appliances (cachedir);
349
350   /* Try to open and acquire a lock on the checksum file. */
351   int fd = open (filename, O_RDONLY);
352   if (fd == -1)
353     return 0;
354 #ifdef HAVE_FUTIMENS
355   (void) futimens (fd, NULL);
356 #else
357   (void) futimes (fd, NULL);
358 #endif
359   struct flock fl;
360   fl.l_type = F_RDLCK;
361   fl.l_whence = SEEK_SET;
362   fl.l_start = 0;
363   fl.l_len = 1;
364  again:
365   if (fcntl (fd, F_SETLKW, &fl) == -1) {
366     if (errno == EINTR)
367       goto again;
368     perrorf (g, "fcntl: F_SETLKW: %s", filename);
369     close (fd);
370     return -1;
371   }
372
373   /* Read the checksum file. */
374   size_t clen = strlen (checksum);
375   char checksum_on_disk[clen];
376   ssize_t rr = read (fd, checksum_on_disk, clen);
377   if (rr == -1) {
378     perrorf (g, "read: %s", filename);
379     close (fd);
380     return -1;
381   }
382   if ((size_t) rr != clen) {
383     close (fd);
384     return 0;
385   }
386
387   if (memcmp (checksum, checksum_on_disk, clen) != 0) {
388     close (fd);
389     return 0;
390   }
391
392   /* At this point, cachedir exists, and checksum matches, and we have
393    * a read lock on the checksum file.  Make hard links to the files.
394    */
395   if (hard_link_to_cached_appliance (g, cachedir,
396                                      kernel, initrd, appliance) == -1) {
397     close (fd);
398     return -1;
399   }
400
401   /* Releases the lock on checksum. */
402   if (close (fd) == -1) {
403     perrorf (g, "close");
404     return -1;
405   }
406
407   /* Exists! */
408   return 1;
409 }
410
411 /* Build supermin appliance from supermin_path to $TMPDIR/.guestfs-$UID.
412  *
413  * Returns:
414  * 0 = built
415  * -1 = error (aborts launch)
416  */
417 static int
418 build_supermin_appliance (guestfs_h *g,
419                           const char *supermin_path, const char *checksum,
420                           uid_t uid,
421                           char **kernel, char **initrd, char **appliance)
422 {
423   if (g->verbose)
424     guestfs___print_timestamped_message (g, "begin building supermin appliance");
425
426   const char *tmpdir = guestfs___persistent_tmpdir ();
427
428   /* len must be longer than the length of any pathname we can
429    * generate in this function.
430    */
431   size_t len = strlen (tmpdir) + 128;
432
433   /* Build the appliance into a temporary directory. */
434   char tmpcd[len];
435   snprintf (tmpcd, len, "%s/guestfs.XXXXXX", tmpdir);
436
437   if (mkdtemp (tmpcd) == NULL) {
438     perrorf (g, "mkdtemp");
439     return -1;
440   }
441
442   if (g->verbose)
443     guestfs___print_timestamped_message (g, "run febootstrap-supermin-helper");
444
445   int r = run_supermin_helper (g, supermin_path, tmpcd, len);
446   if (r == -1)
447     return -1;
448
449   if (g->verbose)
450     guestfs___print_timestamped_message (g, "finished building supermin appliance");
451
452   char cachedir[len];
453   snprintf (cachedir, len, "%s/.guestfs-%d", tmpdir, uid);
454   char filename[len];
455   char filename2[len];
456   snprintf (filename, len, "%s/checksum", cachedir);
457
458   /* Open and acquire write lock on checksum file.  The file might
459    * not exist, in which case we want to create it.
460    */
461   int fd = open (filename, O_WRONLY|O_CREAT, 0755);
462   if (fd == -1) {
463     perrorf (g, "open: %s", filename);
464     return -1;
465   }
466   struct flock fl;
467   fl.l_type = F_WRLCK;
468   fl.l_whence = SEEK_SET;
469   fl.l_start = 0;
470   fl.l_len = 1;
471  again:
472   if (fcntl (fd, F_SETLKW, &fl) == -1) {
473     if (errno == EINTR)
474       goto again;
475     perrorf (g, "fcntl: F_SETLKW: %s", filename);
476     close (fd);
477     return -1;
478   }
479
480   /* At this point we have acquired a write lock on the checksum
481    * file so we go ahead and replace it with the new checksum, and
482    * rename in appliance files into this directory.
483    */
484   size_t clen = strlen (checksum);
485   if (ftruncate (fd, clen) == -1) {
486     perrorf (g, "ftruncate: %s", filename);
487     close (fd);
488     return -1;
489   }
490
491   ssize_t rr = write (fd, checksum, clen);
492   if (rr == -1) {
493     perrorf (g, "write: %s", filename);
494     close (fd);
495     return -1;
496   }
497   if ((size_t) rr != clen) {
498     error (g, "partial write: %s", filename);
499     close (fd);
500     return -1;
501   }
502
503   snprintf (filename, len, "%s/kernel", tmpcd);
504   snprintf (filename2, len, "%s/kernel", cachedir);
505   unlink (filename2);
506   if (rename (filename, filename2) == -1) {
507     perrorf (g, "rename: %s %s", filename, filename2);
508     close (fd);
509     return -1;
510   }
511
512   snprintf (filename, len, "%s/initrd", tmpcd);
513   snprintf (filename2, len, "%s/initrd", cachedir);
514   unlink (filename2);
515   if (rename (filename, filename2) == -1) {
516     perrorf (g, "rename: %s %s", filename, filename2);
517     close (fd);
518     return -1;
519   }
520
521   snprintf (filename, len, "%s/root", tmpcd);
522   snprintf (filename2, len, "%s/root", cachedir);
523   unlink (filename2);
524   if (rename (filename, filename2) == -1) {
525     perrorf (g, "rename: %s %s", filename, filename2);
526     close (fd);
527     return -1;
528   }
529
530   rmdir (tmpcd);
531
532   /* Now finish off by linking to the cached appliance and returning it. */
533   if (hard_link_to_cached_appliance (g, cachedir,
534                                      kernel, initrd, appliance) == -1) {
535     close (fd);
536     return -1;
537   }
538
539   /* Releases the lock on checksum. */
540   if (close (fd) == -1) {
541     perrorf (g, "close");
542     return -1;
543   }
544
545   return 0;
546 }
547
548 /* NB: lock on checksum file must be held when this is called. */
549 static int
550 hard_link_to_cached_appliance (guestfs_h *g,
551                                const char *cachedir,
552                                char **kernel, char **initrd, char **appliance)
553 {
554   pid_t pid = getpid ();
555   size_t len = strlen (cachedir) + 32;
556
557   *kernel = safe_malloc (g, len);
558   *initrd = safe_malloc (g, len);
559   *appliance = safe_malloc (g, len);
560   snprintf (*kernel, len, "%s/kernel.%d", cachedir, pid);
561   snprintf (*initrd, len, "%s/initrd.%d", cachedir, pid);
562   snprintf (*appliance, len, "%s/root.%d", cachedir, pid);
563
564   char filename[len];
565   snprintf (filename, len, "%s/kernel", cachedir);
566   (void) unlink (*kernel);
567   if (link (filename, *kernel) == -1) {
568     perrorf (g, "link: %s %s", filename, *kernel);
569     goto error;
570   }
571   (void) lutimes (filename, NULL); /* lutimes because it's a symlink */
572
573   snprintf (filename, len, "%s/initrd", cachedir);
574   (void) unlink (*initrd);
575   if (link (filename, *initrd) == -1) {
576     perrorf (g, "link: %s %s", filename, *initrd);
577     goto error;
578   }
579   (void) utime (filename, NULL);
580
581   snprintf (filename, len, "%s/root", cachedir);
582   (void) unlink (*appliance);
583   if (link (filename, *appliance) == -1) {
584     perrorf (g, "link: %s %s", filename, *appliance);
585     goto error;
586   }
587   (void) utime (filename, NULL);
588
589   return 0;
590
591  error:
592   free (*kernel);
593   free (*initrd);
594   free (*appliance);
595   return -1;
596 }
597
598 /* Run febootstrap-supermin-helper and tell it to generate the
599  * appliance.
600  */
601 static int
602 run_supermin_helper (guestfs_h *g, const char *supermin_path,
603                      const char *cachedir, size_t cdlen)
604 {
605   size_t pathlen = strlen (supermin_path);
606
607   const char *argv[30];
608   size_t i = 0;
609
610   char uid[32];
611   snprintf (uid, sizeof uid, "%i", geteuid ());
612   char gid[32];
613   snprintf (gid, sizeof gid, "%i", getegid ());
614   char supermin_d[pathlen + 32];
615   snprintf (supermin_d, pathlen + 32, "%s/supermin.d", supermin_path);
616   char kernel[cdlen + 32];
617   snprintf (kernel, cdlen + 32, "%s/kernel", cachedir);
618   char initrd[cdlen + 32];
619   snprintf (initrd, cdlen + 32, "%s/initrd", cachedir);
620   char root[cdlen + 32];
621   snprintf (root, cdlen + 32, "%s/root", cachedir);
622
623   int pass_u_g_args = getuid () != geteuid () || getgid () != getegid ();
624
625   argv[i++] = "febootstrap-supermin-helper";
626   if (g->verbose)
627     argv[i++] = "--verbose";
628   if (pass_u_g_args) {
629     argv[i++] = "-u";
630     argv[i++] = uid;
631     argv[i++] = "-g";
632     argv[i++] = gid;
633   }
634   argv[i++] = "-f";
635   argv[i++] = "ext2";
636   argv[i++] = supermin_d;
637   argv[i++] = host_cpu;
638   argv[i++] = kernel;
639   argv[i++] = initrd;
640   argv[i++] = root;
641   argv[i++] = NULL;
642
643   pid_t pid = fork ();
644   if (pid == -1) {
645     perrorf (g, "fork");
646     return -1;
647   }
648
649   if (pid > 0) {                /* Parent. */
650     if (g->verbose)
651       guestfs___print_timestamped_argv (g, argv);
652
653     int status;
654     if (waitpid (pid, &status, 0) == -1) {
655       perrorf (g, "waitpid");
656       return -1;
657     }
658     if (!WIFEXITED (status) || WEXITSTATUS (status) != 0) {
659       error (g, _("external command failed, see earlier error messages"));
660       return -1;
661     }
662     return 0;
663   }
664
665   /* Child. */
666
667   /* Set a sensible umask in the subprocess, so kernel and initrd
668    * output files are world-readable (RHBZ#610880).
669    */
670   umask (0022);
671
672   execvp ("febootstrap-supermin-helper", (char * const *) argv);
673   perror ("execvp");
674   _exit (EXIT_FAILURE);
675 }
676
677 /* Search elements of g->path, returning the first path element which
678  * matches the predicate function 'pred'.
679  *
680  * Function 'pred' must return a true or false value.  If it returns
681  * -1 then the entire search is aborted.
682  *
683  * Return values:
684  * 1 = a path element matched, it is returned in *pelem_ret and must be
685  *     freed by the caller,
686  * 0 = no path element matched, *pelem_ret is set to NULL, or
687  * -1 = error which aborts the launch process
688  */
689 static int
690 find_path (guestfs_h *g,
691            int (*pred) (guestfs_h *g, const char *pelem, void *data),
692            void *data,
693            char **pelem_ret)
694 {
695   size_t len;
696   int r;
697   const char *pelem = g->path;
698
699   /* Note that if g->path is an empty string, we want to check the
700    * current directory (for backwards compatibility with
701    * libguestfs < 1.5.4).
702    */
703   do {
704     len = strcspn (pelem, ":");
705
706     /* Empty element or "." means current directory. */
707     if (len == 0)
708       *pelem_ret = safe_strdup (g, ".");
709     else
710       *pelem_ret = safe_strndup (g, pelem, len);
711
712     r = pred (g, *pelem_ret, data);
713     if (r == -1) {
714       free (*pelem_ret);
715       return -1;
716     }
717
718     if (r != 0)                 /* predicate matched */
719       return 1;
720
721     free (*pelem_ret);
722
723     if (pelem[len] == ':')
724       pelem += len + 1;
725     else
726       pelem += len;
727   } while (*pelem);
728
729   /* Predicate didn't match on any path element. */
730   *pelem_ret = NULL;
731   return 0;
732 }
733
734 /* Returns true iff file is contained in dir. */
735 static int
736 dir_contains_file (const char *dir, const char *file)
737 {
738   size_t dirlen = strlen (dir);
739   size_t filelen = strlen (file);
740   size_t len = dirlen + filelen + 2;
741   char path[len];
742
743   snprintf (path, len, "%s/%s", dir, file);
744   return access (path, F_OK) == 0;
745 }
746
747 /* Returns true iff every listed file is contained in 'dir'. */
748 static int
749 dir_contains_files (const char *dir, ...)
750 {
751   va_list args;
752   const char *file;
753
754   va_start (args, dir);
755   while ((file = va_arg (args, const char *)) != NULL) {
756     if (!dir_contains_file (dir, file)) {
757       va_end (args);
758       return 0;
759     }
760   }
761   va_end (args);
762   return 1;
763 }