85efd756e74472c312d81a477d78550277045b9b
[febootstrap.git] / helper / appliance.c
1 /* febootstrap-supermin-helper reimplementation in C.
2  * Copyright (C) 2009-2010 Red Hat Inc.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <config.h>
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <fcntl.h>
26 #include <errno.h>
27 #include <dirent.h>
28 #include <fnmatch.h>
29 #include <sys/stat.h>
30 #include <assert.h>
31
32 #include "error.h"
33 #include "fts_.h"
34 #include "xalloc.h"
35 #include "xvasprintf.h"
36
37 #include "helper.h"
38
39 static void iterate_inputs (char **inputs, int nr_inputs, struct writer *);
40 static void iterate_input_directory (const char *dirname, int dirfd, struct writer *);
41 static void add_kernel_modules (const char *whitelist, const char *modpath, struct writer *);
42 static void add_hostfiles (const char *hostfiles_file, struct writer *);
43
44 /* Create the appliance.
45  *
46  * The initrd consists of these components concatenated together:
47  *
48  * (1) The base skeleton appliance that we constructed at build time.
49  *     format = plain cpio
50  * (2) The host files which match wildcards in *.supermin.hostfiles.
51  *     input format = plain text, output format = plain cpio
52  * (3) The modules from modpath which are on the module whitelist.
53  *     output format = plain cpio
54  *
55  * The original shell script used the external cpio program to create
56  * parts (2) and (3), but we have decided it's going to be faster if
57  * we just write out the data outselves.  The reasons are that
58  * external cpio is slow (particularly when used with SELinux because
59  * it does 512 byte reads), and the format that we're writing is
60  * narrow and well understood, because we only care that the Linux
61  * kernel can read it.
62  *
63  * This version contains some improvements over the C version written
64  * for libguestfs, in that we can have multiple base images (or
65  * hostfiles) or use a directory to store these files.
66  */
67 void
68 create_appliance (const char *hostcpu,
69                   char **inputs, int nr_inputs,
70                   const char *whitelist,
71                   const char *modpath,
72                   const char *initrd,
73                   const char *appliance,
74                   struct writer *writer)
75 {
76   writer->wr_start (hostcpu, appliance, modpath, initrd);
77
78   iterate_inputs (inputs, nr_inputs, writer);
79
80   /* Kernel modules (3). */
81   add_kernel_modules (whitelist, modpath, writer);
82
83   writer->wr_end ();
84 }
85
86 /* Iterate over the inputs to find out what they are, visiting
87  * directories if specified.
88  */
89 static void
90 iterate_inputs (char **inputs, int nr_inputs, struct writer *writer)
91 {
92   int i;
93   for (i = 0; i < nr_inputs; ++i) {
94     if (verbose)
95       print_timestamped_message ("visiting %s", inputs[i]);
96
97     int fd = open (inputs[i], O_RDONLY);
98     if (fd == -1)
99       error (EXIT_FAILURE, errno, "open: %s", inputs[i]);
100
101     struct stat statbuf;
102     if (fstat (fd, &statbuf) == -1)
103       error (EXIT_FAILURE, errno, "fstat: %s", inputs[i]);
104
105     /* Directory? */
106     if (S_ISDIR (statbuf.st_mode))
107       iterate_input_directory (inputs[i], fd, writer);
108     else if (S_ISREG (statbuf.st_mode)) {
109       /* Is it a cpio file? */
110       char buf[6];
111       if (read (fd, buf, 6) == 6 && memcmp (buf, "070701", 6) == 0)
112         /* Yes, a cpio file.  This is a skeleton appliance, case (1). */
113         writer->wr_cpio_file (inputs[i]);
114       else
115         /* No, must be hostfiles, case (2). */
116         add_hostfiles (inputs[i], writer);
117     }
118     else
119       error (EXIT_FAILURE, 0, "%s: input is not a regular file or directory",
120              inputs[i]);
121
122     close (fd);
123   }
124 }
125
126 static int
127 string_compare (const void *p1, const void *p2)
128 {
129   return strcmp (* (char * const *) p1, * (char * const *) p2);
130 }
131
132 static void
133 iterate_input_directory (const char *dirname, int dirfd, struct writer *writer)
134 {
135   DIR *dir = fdopendir (dirfd);
136   if (dir == NULL)
137     error (EXIT_FAILURE, errno, "fdopendir: %s", dirname);
138
139   char **entries = NULL;
140   size_t nr_entries = 0, nr_alloc = 0;
141
142   struct dirent *d;
143   while ((errno = 0, d = readdir (dir)) != NULL) {
144     if (d->d_name[0] == '.') /* ignore ., .. and any hidden files. */
145       continue;
146
147     /* Ignore *~ files created by editors. */
148     size_t len = strlen (d->d_name);
149     if (len > 0 && d->d_name[len-1] == '~')
150       continue;
151
152     add_string (&entries, &nr_entries, &nr_alloc, d->d_name);
153   }
154
155   if (errno != 0)
156     error (EXIT_FAILURE, errno, "readdir: %s", dirname);
157
158   if (closedir (dir) == -1)
159     error (EXIT_FAILURE, errno, "closedir: %s", dirname);
160
161   add_string (&entries, &nr_entries, &nr_alloc, NULL);
162
163   /* Visit directory entries in order.  In febootstrap <= 2.8 we
164    * didn't impose any order, but that led to some difficult
165    * heisenbugs.
166    */
167   sort (entries, string_compare);
168
169   char path[PATH_MAX];
170   strcpy (path, dirname);
171   size_t len = strlen (dirname);
172   path[len++] = '/';
173
174   char *inputs[] = { path };
175
176   size_t i;
177   for (i = 0; entries[i] != NULL; ++i) {
178     strcpy (&path[len], entries[i]);
179     iterate_inputs (inputs, 1, writer);
180   }
181 }
182
183 /* Copy kernel modules.
184  *
185  * Find every file under modpath.
186  *
187  * Exclude all *.ko files, *except* ones which match names in
188  * the whitelist (which may contain wildcards).  Include all
189  * other files.
190  *
191  * Add chosen files to the output.
192  *
193  * whitelist_file may be NULL, to include ALL kernel modules.
194  */
195 static void
196 add_kernel_modules (const char *whitelist_file, const char *modpath,
197                     struct writer *writer)
198 {
199   char **whitelist = NULL;
200   if (whitelist_file != NULL)
201     whitelist = load_file (whitelist_file);
202
203   char *paths[2] = { (char *) modpath, NULL };
204   FTS *fts = fts_open (paths, FTS_COMFOLLOW|FTS_PHYSICAL, NULL);
205   if (fts == NULL)
206     error (EXIT_FAILURE, errno, "add_kernel_modules: fts_open: %s", modpath);
207
208   for (;;) {
209     errno = 0;
210     FTSENT *entry = fts_read (fts);
211     if (entry == NULL && errno != 0)
212       error (EXIT_FAILURE, errno, "add_kernel_modules: fts_read: %s", modpath);
213     if (entry == NULL)
214       break;
215
216     /* Ignore directories being visited in post-order. */
217     if (entry->fts_info & FTS_DP)
218       continue;
219
220     /* Is it a *.ko file? */
221     if (entry->fts_namelen >= 3 &&
222         entry->fts_name[entry->fts_namelen-3] == '.' &&
223         entry->fts_name[entry->fts_namelen-2] == 'k' &&
224         entry->fts_name[entry->fts_namelen-1] == 'o') {
225       if (whitelist) {
226         /* Is it a *.ko file which is on the whitelist? */
227         size_t j;
228         for (j = 0; whitelist[j] != NULL; ++j) {
229           int r;
230           r = fnmatch (whitelist[j], entry->fts_name, 0);
231           if (r == 0) {
232             /* It's on the whitelist, so include it. */
233             if (verbose >= 2)
234               fprintf (stderr, "including kernel module %s (matches whitelist entry %s)\n",
235                        entry->fts_name, whitelist[j]);
236             writer->wr_fts_entry (entry);
237             break;
238           } else if (r != FNM_NOMATCH)
239             error (EXIT_FAILURE, 0, "internal error: fnmatch ('%s', '%s', %d) returned unexpected non-zero value %d\n",
240                    whitelist[j], entry->fts_name, 0, r);
241         } /* for (j) */
242       } else { /* whitelist == NULL, always include */
243         if (verbose >= 2)
244           fprintf (stderr, "including kernel module %s\n", entry->fts_name);
245         writer->wr_fts_entry (entry);
246       }
247     } else
248       /* It's some other sort of file, or a directory, always include. */
249       writer->wr_fts_entry (entry);
250   }
251
252   if (fts_close (fts) == -1)
253     error (EXIT_FAILURE, errno, "add_kernel_modules: fts_close: %s", modpath);
254 }
255
256 /* Copy the host files.
257  *
258  * Read the list of entries in hostfiles (which may contain
259  * wildcards).  Look them up in the filesystem, and add those files
260  * that exist.  Ignore any files that don't exist or are not readable.
261  */
262 static void
263 add_hostfiles (const char *hostfiles_file, struct writer *writer)
264 {
265   char **hostfiles = load_file (hostfiles_file);
266
267   /* Hostfiles list can contain "." before each path - ignore it.
268    * It also contains each directory name before we enter it.  But
269    * we don't read that until we see a wildcard for that directory.
270    */
271   size_t i, j;
272   for (i = 0; hostfiles[i] != NULL; ++i) {
273     char *hostfile = hostfiles[i];
274     if (hostfile[0] == '.')
275       hostfile++;
276
277     struct stat statbuf;
278
279     /* Is it a wildcard? */
280     if (strchr (hostfile, '*') || strchr (hostfile, '?')) {
281       char *dirname = xstrdup (hostfile);
282       char *patt = strrchr (dirname, '/');
283       assert (patt);
284       *patt++ = '\0';
285
286       char **files = read_dir (dirname);
287       files = filter_fnmatch (files, patt, FNM_NOESCAPE);
288
289       /* Add matching files. */
290       for (j = 0; files[j] != NULL; ++j) {
291         char *tmp = xasprintf ("%s/%s", dirname, files[j]);
292
293         if (verbose >= 2)
294           fprintf (stderr, "including host file %s (matches %s)\n", tmp, patt);
295
296         writer->wr_file (tmp);
297
298         free (tmp);
299       }
300     }
301     /* Else does this file/directory/whatever exist? */
302     else if (lstat (hostfile, &statbuf) == 0) {
303       if (verbose >= 2)
304         fprintf (stderr, "including host file %s (directly referenced)\n",
305                  hostfile);
306
307       writer->wr_file_stat (hostfile, &statbuf);
308     } /* Ignore files that don't exist. */
309   }
310 }