docs: Routine refresh of the documentation for guestfs(3) and guestfish(1).
[libguestfs.git] / daemon / ext2.c
1 /* libguestfs - the guestfsd daemon
2  * Copyright (C) 2009 Red Hat Inc.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <config.h>
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <unistd.h>
25
26 #include "../src/guestfs_protocol.h"
27 #include "daemon.h"
28 #include "c-ctype.h"
29 #include "actions.h"
30
31 /* Choose which tools like mke2fs to use.  For RHEL 5 (only) there
32  * is a special set of tools which support ext2/3/4.  eg. On RHEL 5,
33  * mke2fs only supports ext2/3, but mke4fs supports ext2/3/4.
34  *
35  * We specify e4fsprogs in the package list to ensure it is loaded
36  * if it exists.
37  */
38 static int
39 e2prog (char *name)
40 {
41   char *p = strstr (name, "e2");
42   if (!p) return 0;
43   p++;
44
45   *p = '4';
46   if (prog_exists (name))
47     return 0;
48
49   *p = '2';
50   if (prog_exists (name))
51     return 0;
52
53   reply_with_error ("cannot find required program %s", name);
54   return -1;
55 }
56
57 char **
58 do_tune2fs_l (const char *device)
59 {
60   int r;
61   char *out, *err;
62   char *p, *pend, *colon;
63   char **ret = NULL;
64   int size = 0, alloc = 0;
65
66   char prog[] = "tune2fs";
67   if (e2prog (prog) == -1)
68     return NULL;
69
70   r = command (&out, &err, prog, "-l", device, NULL);
71   if (r == -1) {
72     reply_with_error ("%s", err);
73     free (err);
74     free (out);
75     return NULL;
76   }
77   free (err);
78
79   p = out;
80
81   /* Discard the first line if it contains "tune2fs ...". */
82   if (STRPREFIX (p, "tune2fs ") || STRPREFIX (p, "tune4fs ")) {
83     p = strchr (p, '\n');
84     if (p) p++;
85     else {
86       reply_with_error ("truncated output");
87       free (out);
88       return NULL;
89     }
90   }
91
92   /* Read the lines and split into "key: value". */
93   while (*p) {
94     pend = strchrnul (p, '\n');
95     if (*pend == '\n') {
96       *pend = '\0';
97       pend++;
98     }
99
100     if (!*p) continue;
101
102     colon = strchr (p, ':');
103     if (colon) {
104       *colon = '\0';
105
106       do { colon++; } while (*colon && c_isspace (*colon));
107
108       if (add_string (&ret, &size, &alloc, p) == -1) {
109         free (out);
110         return NULL;
111       }
112       if (STREQ (colon, "<none>") ||
113           STREQ (colon, "<not available>") ||
114           STREQ (colon, "(none)")) {
115         if (add_string (&ret, &size, &alloc, "") == -1) {
116           free (out);
117           return NULL;
118         }
119       } else {
120         if (add_string (&ret, &size, &alloc, colon) == -1) {
121           free (out);
122           return NULL;
123         }
124       }
125     }
126     else {
127       if (add_string (&ret, &size, &alloc, p) == -1) {
128         free (out);
129         return NULL;
130       }
131       if (add_string (&ret, &size, &alloc, "") == -1) {
132         free (out);
133         return NULL;
134       }
135     }
136
137     p = pend;
138   }
139
140   free (out);
141
142   if (add_string (&ret, &size, &alloc, NULL) == -1)
143     return NULL;
144
145   return ret;
146 }
147
148 int
149 do_set_e2label (const char *device, const char *label)
150 {
151   int r;
152   char *err;
153
154   char prog[] = "e2label";
155   if (e2prog (prog) == -1)
156     return -1;
157
158   r = command (NULL, &err, prog, device, label, NULL);
159   if (r == -1) {
160     reply_with_error ("%s", err);
161     free (err);
162     return -1;
163   }
164
165   free (err);
166   return 0;
167 }
168
169 char *
170 do_get_e2label (const char *device)
171 {
172   int r, len;
173   char *out, *err;
174
175   char prog[] = "e2label";
176   if (e2prog (prog) == -1)
177     return NULL;
178
179   r = command (&out, &err, prog, device, NULL);
180   if (r == -1) {
181     reply_with_error ("%s", err);
182     free (out);
183     free (err);
184     return NULL;
185   }
186
187   free (err);
188
189   /* Remove any trailing \n from the label. */
190   len = strlen (out);
191   if (len > 0 && out[len-1] == '\n')
192     out[len-1] = '\0';
193
194   return out;                   /* caller frees */
195 }
196
197 int
198 do_set_e2uuid (const char *device, const char *uuid)
199 {
200   int r;
201   char *err;
202
203   char prog[] = "tune2fs";
204   if (e2prog (prog) == -1)
205     return -1;
206
207   r = command (NULL, &err, prog, "-U", uuid, device, NULL);
208   if (r == -1) {
209     reply_with_error ("%s", err);
210     free (err);
211     return -1;
212   }
213
214   free (err);
215   return 0;
216 }
217
218 char *
219 do_get_e2uuid (const char *device)
220 {
221   int r;
222   char *out, *err, *p, *q;
223
224   /* It's not so straightforward to get the volume UUID.  We have
225    * to use tune2fs -l and then look for a particular string in
226    * the output.
227    */
228   char prog[] = "tune2fs";
229   if (e2prog (prog) == -1)
230     return NULL;
231
232   r = command (&out, &err, prog, "-l", device, NULL);
233   if (r == -1) {
234     reply_with_error ("%s", err);
235     free (out);
236     free (err);
237     return NULL;
238   }
239
240   free (err);
241
242   /* Look for /\nFilesystem UUID:\s+/ in the output. */
243   p = strstr (out, "\nFilesystem UUID:");
244   if (p == NULL) {
245     reply_with_error ("no Filesystem UUID in the output of tune2fs -l");
246     free (out);
247     return NULL;
248   }
249
250   p += 17;
251   while (*p && c_isspace (*p))
252     p++;
253   if (!*p) {
254     reply_with_error ("malformed Filesystem UUID in the output of tune2fs -l");
255     free (out);
256     return NULL;
257   }
258
259   /* Now 'p' hopefully points to the start of the UUID. */
260   q = p;
261   while (*q && (c_isxdigit (*q) || *q == '-'))
262     q++;
263   if (!*q) {
264     reply_with_error ("malformed Filesystem UUID in the output of tune2fs -l");
265     free (out);
266     return NULL;
267   }
268
269   *q = '\0';
270
271   p = strdup (p);
272   if (!p) {
273     reply_with_perror ("strdup");
274     free (out);
275     return NULL;
276   }
277
278   free (out);
279   return p;                     /* caller frees */
280 }
281
282 int
283 do_resize2fs (const char *device)
284 {
285   char *err;
286   int r;
287
288   char prog[] = "resize2fs";
289   if (e2prog (prog) == -1)
290     return -1;
291
292   r = command (NULL, &err, prog, device, NULL);
293   if (r == -1) {
294     reply_with_error ("%s", err);
295     free (err);
296     return -1;
297   }
298
299   free (err);
300   return 0;
301 }
302
303 int
304 do_e2fsck_f (const char *device)
305 {
306   char *err;
307   int r;
308
309   char prog[] = "e2fsck";
310   if (e2prog (prog) == -1)
311     return -1;
312
313   /* 0 = no errors, 1 = errors corrected.
314    *
315    * >= 4 means uncorrected or other errors.
316    *
317    * 2, 3 means errors were corrected and we require a reboot.  This is
318    * a difficult corner case.
319    */
320   r = commandr (NULL, &err, prog, "-p", "-f", device, NULL);
321   if (r == -1 || r >= 2) {
322     reply_with_error ("%s", err);
323     free (err);
324     return -1;
325   }
326
327   free (err);
328   return 0;
329 }
330
331 int
332 do_mke2journal (int blocksize, const char *device)
333 {
334   char *err;
335   int r;
336
337   char prog[] = "mke2fs";
338   if (e2prog (prog) == -1)
339     return -1;
340
341   char blocksize_s[32];
342   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
343
344   r = command (NULL, &err,
345                prog, "-O", "journal_dev", "-b", blocksize_s,
346                device, NULL);
347   if (r == -1) {
348     reply_with_error ("%s", err);
349     free (err);
350     return -1;
351   }
352
353   free (err);
354   return 0;
355 }
356
357 int
358 do_mke2journal_L (int blocksize, const char *label, const char *device)
359 {
360   char *err;
361   int r;
362
363   char prog[] = "mke2fs";
364   if (e2prog (prog) == -1)
365     return -1;
366
367   char blocksize_s[32];
368   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
369
370   r = command (NULL, &err,
371                prog, "-O", "journal_dev", "-b", blocksize_s,
372                "-L", label,
373                device, NULL);
374   if (r == -1) {
375     reply_with_error ("%s", err);
376     free (err);
377     return -1;
378   }
379
380   free (err);
381   return 0;
382 }
383
384 int
385 do_mke2journal_U (int blocksize, const char *uuid, const char *device)
386 {
387   char *err;
388   int r;
389
390   char prog[] = "mke2fs";
391   if (e2prog (prog) == -1)
392     return -1;
393
394   char blocksize_s[32];
395   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
396
397   r = command (NULL, &err,
398                prog, "-O", "journal_dev", "-b", blocksize_s,
399                "-U", uuid,
400                device, NULL);
401   if (r == -1) {
402     reply_with_error ("%s", err);
403     free (err);
404     return -1;
405   }
406
407   free (err);
408   return 0;
409 }
410
411 int
412 do_mke2fs_J (const char *fstype, int blocksize, const char *device,
413              const char *journal)
414 {
415   char *err;
416   int r;
417
418   char prog[] = "mke2fs";
419   if (e2prog (prog) == -1)
420     return -1;
421
422   char blocksize_s[32];
423   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
424
425   int len = strlen (journal);
426   char jdev[len+32];
427   snprintf (jdev, len+32, "device=%s", journal);
428
429   r = command (NULL, &err,
430                prog, "-t", fstype, "-J", jdev, "-b", blocksize_s,
431                device, NULL);
432   if (r == -1) {
433     reply_with_error ("%s", err);
434     free (err);
435     return -1;
436   }
437
438   free (err);
439   return 0;
440 }
441
442 int
443 do_mke2fs_JL (const char *fstype, int blocksize, const char *device,
444               const char *label)
445 {
446   char *err;
447   int r;
448
449   char prog[] = "mke2fs";
450   if (e2prog (prog) == -1)
451     return -1;
452
453   char blocksize_s[32];
454   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
455
456   int len = strlen (label);
457   char jdev[len+32];
458   snprintf (jdev, len+32, "device=LABEL=%s", label);
459
460   r = command (NULL, &err,
461                prog, "-t", fstype, "-J", jdev, "-b", blocksize_s,
462                device, NULL);
463   if (r == -1) {
464     reply_with_error ("%s", err);
465     free (err);
466     return -1;
467   }
468
469   free (err);
470   return 0;
471 }
472
473 int
474 do_mke2fs_JU (const char *fstype, int blocksize, const char *device,
475               const char *uuid)
476 {
477   char *err;
478   int r;
479
480   char prog[] = "mke2fs";
481   if (e2prog (prog) == -1)
482     return -1;
483
484   char blocksize_s[32];
485   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
486
487   int len = strlen (uuid);
488   char jdev[len+32];
489   snprintf (jdev, len+32, "device=UUID=%s", uuid);
490
491   r = command (NULL, &err,
492                prog, "-t", fstype, "-J", jdev, "-b", blocksize_s,
493                device, NULL);
494   if (r == -1) {
495     reply_with_error ("%s", err);
496     free (err);
497     return -1;
498   }
499
500   free (err);
501   return 0;
502 }