test-tool: Document the -t command line option.
[libguestfs.git] / cat / virt-filesystems.c
1 /* virt-filesystems
2  * Copyright (C) 2010-2011 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 <stdint.h>
24 #include <inttypes.h>
25 #include <unistd.h>
26 #include <getopt.h>
27 #include <locale.h>
28 #include <assert.h>
29 #include <string.h>
30 #include <libintl.h>
31
32 #include "c-ctype.h"
33 #include "human.h"
34 #include "progname.h"
35
36 #include "guestfs.h"
37 #include "options.h"
38
39 #define DISABLE_GUESTFS_ERRORS_FOR(stmt) do {                           \
40     guestfs_error_handler_cb old_error_cb;                              \
41     void *old_error_data;                                               \
42     old_error_cb = guestfs_get_error_handler (g, &old_error_data);      \
43     guestfs_set_error_handler (g, NULL, NULL);                          \
44     stmt;                                                               \
45     guestfs_set_error_handler (g, old_error_cb, old_error_data);        \
46   } while (0)
47
48 /* These globals are shared with options.c. */
49 guestfs_h *g;
50
51 int read_only = 1;
52 int live = 0;
53 int verbose = 0;
54 int keys_from_stdin = 0;
55 int echo_keys = 0;
56 const char *libvirt_uri = NULL;
57 int inspector = 0;
58
59 static int csv = 0;             /* --csv */
60 static int human = 0;           /* --human-readable|-h */
61
62 /* What is selected for output. */
63 #define OUTPUT_FILESYSTEMS        1
64 #define OUTPUT_FILESYSTEMS_EXTRA  2
65 #define OUTPUT_PARTITIONS         4
66 #define OUTPUT_BLOCKDEVS          8
67 #define OUTPUT_LVS               16
68 #define OUTPUT_VGS               32
69 #define OUTPUT_PVS               64
70 #define OUTPUT_ALL          INT_MAX
71 static int output = 0;
72
73 /* What columns to output.  This is in display order. */
74 #define COLUMN_NAME               1 /* always shown */
75 #define COLUMN_TYPE               2
76 #define COLUMN_VFS_TYPE           4 /* if --filesystems */
77 #define COLUMN_VFS_LABEL          8 /* if --filesystems */
78 #define COLUMN_SIZE              16 /* bytes, or human-readable if -h */
79 #define COLUMN_PARENT_NAME       32 /* only for partitions, LVs */
80 #define COLUMN_UUID              64 /* if --uuid */
81 #define NR_COLUMNS                7
82 static int columns;
83
84 static char *canonical_device (const char *dev);
85 static void do_output_title (void);
86 static void do_output (void);
87 static void do_output_end (void);
88
89 static inline char *
90 bad_cast (char const *s)
91 {
92   return (char *) s;
93 }
94
95 static void __attribute__((noreturn))
96 usage (int status)
97 {
98   if (status != EXIT_SUCCESS)
99     fprintf (stderr, _("Try `%s --help' for more information.\n"),
100              program_name);
101   else {
102     fprintf (stdout,
103            _("%s: list filesystems, partitions, block devices, LVM in a VM\n"
104              "Copyright (C) 2010 Red Hat Inc.\n"
105              "Usage:\n"
106              "  %s [--options] -d domname\n"
107              "  %s [--options] -a disk.img [-a disk.img ...]\n"
108              "Options:\n"
109              "  -a|--add image       Add image\n"
110              "  --all                Display everything\n"
111              "  --blkdevs|--block-devices\n"
112              "                       Display block devices\n"
113              "  -c|--connect uri     Specify libvirt URI for -d option\n"
114              "  --csv                Output as Comma-Separated Values\n"
115              "  -d|--domain guest    Add disks from libvirt guest\n"
116              "  --echo-keys          Don't turn off echo for passphrases\n"
117              "  --extra              Display swap and data filesystems\n"
118              "  --filesystems        Display mountable filesystems\n"
119              "  --format[=raw|..]    Force disk format for -a option\n"
120              "  -h|--human-readable  Human-readable sizes in --long output\n"
121              "  --help               Display brief help\n"
122              "  --keys-from-stdin    Read passphrases from stdin\n"
123              "  -l|--long            Long output\n"
124              "  --lvs|--logvols|--logical-volumes\n"
125              "                       Display LVM logical volumes\n"
126              "  --no-title           No title in --long output\n"
127              "  --parts|--partitions Display partitions\n"
128              "  --pvs|--physvols|--physical-volumes\n"
129              "                       Display LVM physical volumes\n"
130              "  --uuid|--uuids       Add UUIDs to --long output\n"
131              "  -v|--verbose         Verbose messages\n"
132              "  -V|--version         Display version and exit\n"
133              "  --vgs|--volgroups|--volume-groups\n"
134              "                       Display LVM volume groups\n"
135              "  -x                   Trace libguestfs API calls\n"
136              "For more information, see the manpage %s(1).\n"),
137              program_name, program_name, program_name,
138              program_name);
139   }
140   exit (status);
141 }
142
143 int
144 main (int argc, char *argv[])
145 {
146   /* Set global program name that is not polluted with libtool artifacts.  */
147   set_program_name (argv[0]);
148
149   setlocale (LC_ALL, "");
150   bindtextdomain (PACKAGE, LOCALEBASEDIR);
151   textdomain (PACKAGE);
152
153   enum { HELP_OPTION = CHAR_MAX + 1 };
154
155   static const char *options = "a:c:d:hlvVx";
156   static const struct option long_options[] = {
157     { "add", 1, 0, 'a' },
158     { "all", 0, 0, 0 },
159     { "blkdevs", 0, 0, 0 },
160     { "block-devices", 0, 0, 0 },
161     { "connect", 1, 0, 'c' },
162     { "csv", 0, 0, 0 },
163     { "domain", 1, 0, 'd' },
164     { "echo-keys", 0, 0, 0 },
165     { "extra", 0, 0, 0 },
166     { "filesystems", 0, 0, 0 },
167     { "format", 2, 0, 0 },
168     { "help", 0, 0, HELP_OPTION },
169     { "human-readable", 0, 0, 'h' },
170     { "keys-from-stdin", 0, 0, 0 },
171     { "long", 0, 0, 'l' },
172     { "logical-volumes", 0, 0, 0 },
173     { "logvols", 0, 0, 0 },
174     { "lvs", 0, 0, 0 },
175     { "no-title", 0, 0, 0 },
176     { "parts", 0, 0, 0 },
177     { "partitions", 0, 0, 0 },
178     { "physical-volumes", 0, 0, 0 },
179     { "physvols", 0, 0, 0 },
180     { "pvs", 0, 0, 0 },
181     { "uuid", 0, 0, 0 },
182     { "uuids", 0, 0, 0 },
183     { "verbose", 0, 0, 'v' },
184     { "version", 0, 0, 'V' },
185     { "vgs", 0, 0, 0 },
186     { "volgroups", 0, 0, 0 },
187     { "volume-groups", 0, 0, 0 },
188     { 0, 0, 0, 0 }
189   };
190   struct drv *drvs = NULL;
191   struct drv *drv;
192   const char *format = NULL;
193   int c;
194   int option_index;
195   int no_title = 0;             /* --no-title */
196   int long_mode = 0;            /* --long|-l */
197   int uuid = 0;                 /* --uuid */
198   int title;
199
200   g = guestfs_create ();
201   if (g == NULL) {
202     fprintf (stderr, _("guestfs_create: failed to create handle\n"));
203     exit (EXIT_FAILURE);
204   }
205
206   argv[0] = bad_cast (program_name);
207
208   for (;;) {
209     c = getopt_long (argc, argv, options, long_options, &option_index);
210     if (c == -1) break;
211
212     switch (c) {
213     case 0:                     /* options which are long only */
214       if (STREQ (long_options[option_index].name, "keys-from-stdin")) {
215         keys_from_stdin = 1;
216       } else if (STREQ (long_options[option_index].name, "echo-keys")) {
217         echo_keys = 1;
218       } else if (STREQ (long_options[option_index].name, "format")) {
219         if (!optarg || STREQ (optarg, ""))
220           format = NULL;
221         else
222           format = optarg;
223       } else if (STREQ (long_options[option_index].name, "all")) {
224         output = OUTPUT_ALL;
225       } else if (STREQ (long_options[option_index].name, "blkdevs") ||
226                  STREQ (long_options[option_index].name, "block-devices")) {
227         output |= OUTPUT_BLOCKDEVS;
228       } else if (STREQ (long_options[option_index].name, "csv")) {
229         csv = 1;
230       } else if (STREQ (long_options[option_index].name, "extra")) {
231         output |= OUTPUT_FILESYSTEMS;
232         output |= OUTPUT_FILESYSTEMS_EXTRA;
233       } else if (STREQ (long_options[option_index].name, "filesystems")) {
234         output |= OUTPUT_FILESYSTEMS;
235       } else if (STREQ (long_options[option_index].name, "logical-volumes") ||
236                  STREQ (long_options[option_index].name, "logvols") ||
237                  STREQ (long_options[option_index].name, "lvs")) {
238         output |= OUTPUT_LVS;
239       } else if (STREQ (long_options[option_index].name, "no-title")) {
240         no_title = 1;
241       } else if (STREQ (long_options[option_index].name, "parts") ||
242                  STREQ (long_options[option_index].name, "partitions")) {
243         output |= OUTPUT_PARTITIONS;
244       } else if (STREQ (long_options[option_index].name, "physical-volumes") ||
245                  STREQ (long_options[option_index].name, "physvols") ||
246                  STREQ (long_options[option_index].name, "pvs")) {
247         output |= OUTPUT_PVS;
248       } else if (STREQ (long_options[option_index].name, "uuid") ||
249                  STREQ (long_options[option_index].name, "uuids")) {
250         uuid = 1;
251       } else if (STREQ (long_options[option_index].name, "vgs") ||
252                  STREQ (long_options[option_index].name, "volgroups") ||
253                  STREQ (long_options[option_index].name, "volume-groups")) {
254         output |= OUTPUT_VGS;
255       } else {
256         fprintf (stderr, _("%s: unknown long option: %s (%d)\n"),
257                  program_name, long_options[option_index].name, option_index);
258         exit (EXIT_FAILURE);
259       }
260       break;
261
262     case 'a':
263       OPTION_a;
264       break;
265
266     case 'c':
267       OPTION_c;
268       break;
269
270     case 'd':
271       OPTION_d;
272       break;
273
274     case 'h':
275       human = 1;
276       break;
277
278     case 'l':
279       long_mode = 1;
280       break;
281
282     case 'v':
283       OPTION_v;
284       break;
285
286     case 'V':
287       OPTION_V;
288       break;
289
290     case 'x':
291       OPTION_x;
292       break;
293
294     case HELP_OPTION:
295       usage (EXIT_SUCCESS);
296
297     default:
298       usage (EXIT_FAILURE);
299     }
300   }
301
302   /* These are really constants, but they have to be variables for the
303    * options parsing code.  Assert here that they have known-good
304    * values.
305    */
306   assert (read_only == 1);
307   assert (inspector == 0);
308   assert (live == 0);
309
310   /* Must be no extra arguments on the command line. */
311   if (optind != argc)
312     usage (EXIT_FAILURE);
313
314   /* -h and --csv doesn't make sense.  Spreadsheets will corrupt these
315    * fields.  (RHBZ#600977).
316    */
317   if (human && csv) {
318     fprintf (stderr, _("%s: you cannot use -h and --csv options together.\n"),
319              program_name);
320     exit (EXIT_FAILURE);
321   }
322
323   /* Nothing selected for output, means --filesystems is implied. */
324   if (output == 0)
325     output = OUTPUT_FILESYSTEMS;
326
327   /* What columns will be displayed? */
328   columns = COLUMN_NAME;
329   if (long_mode) {
330     columns |= COLUMN_TYPE;
331     columns |= COLUMN_SIZE;
332     if ((output & OUTPUT_FILESYSTEMS)) {
333       columns |= COLUMN_VFS_TYPE;
334       columns |= COLUMN_VFS_LABEL;
335     }
336     if ((output & (OUTPUT_PARTITIONS|OUTPUT_LVS)))
337       columns |= COLUMN_PARENT_NAME;
338     if (uuid)
339       columns |= COLUMN_UUID;
340   }
341
342   /* Display title by default only in long mode. */
343   title = long_mode;
344   if (no_title)
345     title = 0;
346
347   /* User must have specified some drives. */
348   if (drvs == NULL)
349     usage (EXIT_FAILURE);
350
351   /* Add drives. */
352   add_drives (drvs, 'a');
353
354   if (guestfs_launch (g) == -1)
355     exit (EXIT_FAILURE);
356
357   /* Free up data structures, no longer needed after this point. */
358   free_drives (drvs);
359
360   if (title)
361     do_output_title ();
362   do_output ();
363   do_output_end ();
364
365   guestfs_close (g);
366
367   exit (EXIT_SUCCESS);
368 }
369
370 static void do_output_filesystems (void);
371 static void do_output_lvs (void);
372 static void do_output_vgs (void);
373 static void do_output_pvs (void);
374 static void do_output_partitions (void);
375 static void do_output_blockdevs (void);
376 static void write_row (const char *name, const char *type, const char *vfs_type, const char *vfs_label, int64_t size, const char *parent_name, const char *uuid);
377 static void write_row_strings (char **strings, size_t len);
378
379 static void
380 do_output_title (void)
381 {
382   const char *headings[NR_COLUMNS];
383   size_t len = 0;
384
385   /* NB. These strings are not localized and must not contain spaces. */
386   if ((columns & COLUMN_NAME))
387     headings[len++] = "Name";
388   if ((columns & COLUMN_TYPE))
389     headings[len++] = "Type";
390   if ((columns & COLUMN_VFS_TYPE))
391     headings[len++] = "VFS";
392   if ((columns & COLUMN_VFS_LABEL))
393     headings[len++] = "Label";
394   if ((columns & COLUMN_SIZE))
395     headings[len++] = "Size";
396   if ((columns & COLUMN_PARENT_NAME))
397     headings[len++] = "Parent";
398   if ((columns & COLUMN_UUID))
399     headings[len++] = "UUID";
400   assert (len <= NR_COLUMNS);
401
402   write_row_strings ((char **) headings, len);
403 }
404
405 static void
406 do_output (void)
407 {
408   /* The ordering here is trying to be most specific -> least specific,
409    * although that is not required or guaranteed.
410    */
411   if ((output & OUTPUT_FILESYSTEMS))
412     do_output_filesystems ();
413
414   if ((output & OUTPUT_LVS))
415     do_output_lvs ();
416
417   if ((output & OUTPUT_VGS))
418     do_output_vgs ();
419
420   if ((output & OUTPUT_PVS))
421     do_output_pvs ();
422
423   if ((output & OUTPUT_PARTITIONS))
424     do_output_partitions ();
425
426   if ((output & OUTPUT_BLOCKDEVS))
427     do_output_blockdevs ();
428 }
429
430 static void
431 do_output_filesystems (void)
432 {
433   char **fses;
434   size_t i;
435
436   fses = guestfs_list_filesystems (g);
437   if (fses == NULL)
438     exit (EXIT_FAILURE);
439
440   for (i = 0; fses[i] != NULL; i += 2) {
441     char *dev, *vfs_label = NULL, *vfs_uuid = NULL;
442     int64_t size = -1;
443
444     /* Skip swap and unknown, unless --extra flag was given. */
445     if (!(output & OUTPUT_FILESYSTEMS_EXTRA) &&
446         (STREQ (fses[i+1], "swap") || STREQ (fses[i+1], "unknown")))
447       continue;
448
449     dev = canonical_device (fses[i]);
450
451     /* Only bother to look these up if we will be displaying them,
452      * otherwise pass them as NULL.
453      */
454     if ((columns & COLUMN_VFS_LABEL)) {
455       DISABLE_GUESTFS_ERRORS_FOR (
456         vfs_label = guestfs_vfs_label (g, fses[i]);
457       );
458       if (vfs_label == NULL) {
459         vfs_label = strdup ("");
460         if (!vfs_label) {
461           perror ("strdup");
462           exit (EXIT_FAILURE);
463         }
464       }
465     }
466     if ((columns & COLUMN_UUID)) {
467       DISABLE_GUESTFS_ERRORS_FOR (
468         vfs_uuid = guestfs_vfs_uuid (g, fses[i]);
469       );
470       if (vfs_uuid == NULL) {
471         vfs_uuid = strdup ("");
472         if (!vfs_uuid) {
473           perror ("strdup");
474           exit (EXIT_FAILURE);
475         }
476       }
477     }
478     if ((columns & COLUMN_SIZE)) {
479       size = guestfs_blockdev_getsize64 (g, fses[i]);
480       if (size == -1)
481         exit (EXIT_FAILURE);
482     }
483
484     write_row (dev, "filesystem",
485                fses[i+1], vfs_label, size, NULL, vfs_uuid);
486
487     free (dev);
488     free (vfs_label);
489     free (vfs_uuid);
490     free (fses[i]);
491     free (fses[i+1]);
492   }
493
494   free (fses);
495 }
496
497 static void
498 do_output_lvs (void)
499 {
500   char **lvs;
501   size_t i;
502
503   lvs = guestfs_lvs (g);
504   if (lvs == NULL)
505     exit (EXIT_FAILURE);
506
507   for (i = 0; lvs[i] != NULL; ++i) {
508     char *uuid = NULL, *parent_name = NULL;
509     int64_t size = -1;
510
511     if ((columns & COLUMN_SIZE)) {
512       size = guestfs_blockdev_getsize64 (g, lvs[i]);
513       if (size == -1)
514         exit (EXIT_FAILURE);
515     }
516     if ((columns & COLUMN_UUID)) {
517       uuid = guestfs_lvuuid (g, lvs[i]);
518       if (uuid == NULL)
519         exit (EXIT_FAILURE);
520     }
521     if ((columns & COLUMN_PARENT_NAME)) {
522       parent_name = strdup (lvs[i]);
523       if (parent_name == NULL) {
524         perror ("strdup");
525         exit (EXIT_FAILURE);
526       }
527       char *p = strrchr (parent_name, '/');
528       if (p)
529         *p = '\0';
530     }
531
532     write_row (lvs[i], "lv",
533                NULL, NULL, size, parent_name, uuid);
534
535     free (uuid);
536     free (parent_name);
537     free (lvs[i]);
538   }
539
540   free (lvs);
541 }
542
543 static void
544 do_output_vgs (void)
545 {
546   struct guestfs_lvm_vg_list *vgs;
547   size_t i;
548
549   vgs = guestfs_vgs_full (g);
550   if (vgs == NULL)
551     exit (EXIT_FAILURE);
552
553   for (i = 0; i < vgs->len; ++i) {
554     char name[PATH_MAX];
555     char uuid[33];
556
557     strcpy (name, "/dev/");
558     strcpy (&name[5], vgs->val[i].vg_name);
559     memcpy (uuid, vgs->val[i].vg_uuid, 32);
560     uuid[32] = '\0';
561     write_row (name, "vg",
562                NULL, NULL, (int64_t) vgs->val[i].vg_size, NULL, uuid);
563
564   }
565
566   guestfs_free_lvm_vg_list (vgs);
567 }
568
569 static void
570 do_output_pvs (void)
571 {
572   struct guestfs_lvm_pv_list *pvs;
573   size_t i;
574
575   pvs = guestfs_pvs_full (g);
576   if (pvs == NULL)
577     exit (EXIT_FAILURE);
578
579   for (i = 0; i < pvs->len; ++i) {
580     char *dev;
581     char uuid[33];
582
583     dev = canonical_device (pvs->val[i].pv_name);
584
585     memcpy (uuid, pvs->val[i].pv_uuid, 32);
586     uuid[32] = '\0';
587     write_row (dev, "pv",
588                NULL, NULL, (int64_t) pvs->val[i].pv_size, NULL, uuid);
589
590     free (dev);
591   }
592
593   guestfs_free_lvm_pv_list (pvs);
594 }
595
596 static void
597 do_output_partitions (void)
598 {
599   char **parts;
600   size_t i;
601
602   parts = guestfs_list_partitions (g);
603   if (parts == NULL)
604     exit (EXIT_FAILURE);
605
606   for (i = 0; parts[i] != NULL; ++i) {
607     char *dev, *parent_name = NULL;
608     int64_t size = -1;
609
610     dev = canonical_device (parts[i]);
611
612     if ((columns & COLUMN_SIZE)) {
613       size = guestfs_blockdev_getsize64 (g, parts[i]);
614       if (size == -1)
615         exit (EXIT_FAILURE);
616     }
617     if ((columns & COLUMN_PARENT_NAME)) {
618       parent_name = guestfs_part_to_dev (g, parts[i]);
619       if (parent_name == NULL)
620         exit (EXIT_FAILURE);
621       char *p = canonical_device (parent_name);
622       free (parent_name);
623       parent_name = p;
624     }
625
626     write_row (dev, "partition",
627                NULL, NULL, size, parent_name, NULL);
628
629     free (dev);
630     free (parent_name);
631     free (parts[i]);
632   }
633
634   free (parts);
635 }
636
637 static void
638 do_output_blockdevs (void)
639 {
640   char **devices;
641   size_t i;
642
643   devices = guestfs_list_devices (g);
644   if (devices == NULL)
645     exit (EXIT_FAILURE);
646
647   for (i = 0; devices[i] != NULL; ++i) {
648     int64_t size = -1;
649     char *dev;
650
651     dev = canonical_device (devices[i]);
652
653     if ((columns & COLUMN_SIZE)) {
654       size = guestfs_blockdev_getsize64 (g, devices[i]);
655       if (size == -1)
656         exit (EXIT_FAILURE);
657     }
658
659     write_row (dev, "device",
660                NULL, NULL, size, NULL, NULL);
661
662     free (dev);
663     free (devices[i]);
664   }
665
666   free (devices);
667 }
668
669 /* /dev/vda1 -> /dev/sda.  Returns a string which the caller must free. */
670 static char *
671 canonical_device (const char *dev)
672 {
673   char *ret = strdup (dev);
674   if (ret == NULL) {
675     perror ("strdup");
676     exit (EXIT_FAILURE);
677   }
678
679   if (STRPREFIX (ret, "/dev/") &&
680       (ret[5] == 'h' || ret[5] == 'v') &&
681       ret[6] == 'd' &&
682       c_isalpha (ret[7]) &&
683       (c_isdigit (ret[8]) || ret[8] == '\0'))
684     ret[5] = 's';
685
686   return ret;
687 }
688
689 static void
690 write_row (const char *name, const char *type,
691            const char *vfs_type, const char *vfs_label,
692            int64_t size, const char *parent_name, const char *uuid)
693 {
694   const char *strings[NR_COLUMNS];
695   size_t len = 0;
696   char hum[LONGEST_HUMAN_READABLE];
697   char num[256];
698
699   if ((columns & COLUMN_NAME))
700     strings[len++] = name;
701   if ((columns & COLUMN_TYPE))
702     strings[len++] = type;
703   if ((columns & COLUMN_VFS_TYPE))
704     strings[len++] = vfs_type;
705   if ((columns & COLUMN_VFS_LABEL))
706     strings[len++] = vfs_label;
707   if ((columns & COLUMN_SIZE)) {
708     if (size >= 0) {
709       if (human) {
710         strings[len++] =
711           human_readable ((uintmax_t) size, hum,
712                           human_round_to_nearest|human_autoscale|
713                           human_base_1024|human_SI,
714                           1, 1);
715       }
716       else {
717         snprintf (num, sizeof num, "%" PRIi64, size);
718         strings[len++] = num;
719       }
720     }
721     else
722       strings[len++] = NULL;
723   }
724   if ((columns & COLUMN_PARENT_NAME))
725     strings[len++] = parent_name;
726   if ((columns & COLUMN_UUID))
727     strings[len++] = uuid;
728   assert (len <= NR_COLUMNS);
729
730   write_row_strings ((char **) strings, len);
731 }
732
733 static void add_row (char **strings, size_t len);
734 static void write_csv_field (const char *field);
735
736 static void
737 write_row_strings (char **strings, size_t len)
738 {
739   if (!csv) {
740     /* Text mode.  Because we want the columns to line up, we can't
741      * output directly, but instead need to save up the rows and
742      * output them at the end.
743      */
744     add_row (strings, len);
745   }
746   else {                    /* CSV mode: output it directly, quoted */
747     size_t i;
748
749     for (i = 0; i < len; ++i) {
750       if (i > 0)
751         putchar (',');
752       if (strings[i] != NULL)
753         write_csv_field (strings[i]);
754     }
755     putchar ('\n');
756   }
757 }
758
759 /* Function to quote CSV fields on output without requiring an
760  * external module.
761  */
762 static void
763 write_csv_field (const char *field)
764 {
765   size_t i, len;
766   int needs_quoting = 0;
767
768   len = strlen (field);
769
770   for (i = 0; i < len; ++i) {
771     if (field[i] == ' ' || field[i] == '"' ||
772         field[i] == '\n' || field[i] == ',') {
773       needs_quoting = 1;
774       break;
775     }
776   }
777
778   if (!needs_quoting) {
779     printf ("%s", field);
780     return;
781   }
782
783   /* Quoting for CSV fields. */
784   putchar ('"');
785   for (i = 0; i < len; ++i) {
786     if (field[i] == '"') {
787       putchar ('"');
788       putchar ('"');
789     } else
790       putchar (field[i]);
791   }
792   putchar ('"');
793 }
794
795 /* This code is only used in text mode (non-CSV output). */
796 static char ***rows = NULL;
797 static size_t nr_rows = 0;
798 static size_t max_width[NR_COLUMNS];
799
800 static void
801 add_row (char **strings, size_t len)
802 {
803   size_t i, slen;
804   char **row;
805
806   assert (len <= NR_COLUMNS);
807
808   row = malloc (sizeof (char *) * len);
809   if (row == NULL) {
810     perror ("malloc");
811     exit (EXIT_FAILURE);
812   }
813
814   for (i = 0; i < len; ++i) {
815     if (strings[i]) {
816       row[i] = strdup (strings[i]);
817       if (row[i] == NULL) {
818         perror ("strdup");
819         exit (EXIT_FAILURE);
820       }
821
822       /* Keep a running total of the max width of each column. */
823       slen = strlen (strings[i]);
824       if (slen == 0)
825         slen = 1; /* because "" is printed as "-" */
826       if (slen > max_width[i])
827         max_width[i] = slen;
828     }
829     else
830       row[i] = NULL;
831   }
832
833   rows = realloc (rows, sizeof (char **) * (nr_rows + 1));
834   if (rows == NULL) {
835     perror ("realloc");
836     exit (EXIT_FAILURE);
837   }
838   rows[nr_rows] = row;
839   nr_rows++;
840 }
841
842 /* In text mode we saved up all the output so that we can print the
843  * columns aligned.
844  */
845 static void
846 do_output_end (void)
847 {
848   size_t i, j, k, len, space_btwn;
849
850   if (csv)
851     return;
852
853   /* How much space between columns?  Try 2 spaces between columns, but
854    * if that just pushes us over 72 columns, use 1 space.
855    */
856   space_btwn = 2;
857   i = 0;
858   for (j = 0; j < NR_COLUMNS; ++j)
859     i += max_width[j] + space_btwn;
860   if (i > 72)
861     space_btwn = 1;
862
863   for (i = 0; i < nr_rows; ++i) {
864     char **row = rows[i];
865
866     k = 0;
867
868     for (j = 0; j < NR_COLUMNS; ++j) {
869       /* Ignore columns which are completely empty.  This also deals
870        * with the fact that we didn't remember the length of each row
871        * in add_row above.
872        */
873       if (max_width[j] == 0)
874         continue;
875
876       while (k) {
877         putchar (' ');
878         k--;
879       }
880
881       if (row[j] == NULL || STREQ (row[j], "")) {
882         printf ("-");
883         len = 1;
884       } else {
885         printf ("%s", row[j]);
886         len = strlen (row[j]);
887       }
888       free (row[j]);
889
890       assert (len <= max_width[j]);
891       k = max_width[j] - len + space_btwn;
892     }
893
894     putchar ('\n');
895     free (row);
896   }
897   free (rows);
898 }