misc-utils/uuidparse.c

   1 /*
   2  * uuidparse.c --- Interpret uuid encoded information.  This program
   3  *      violates the UUID abstraction barrier by reaching into the
   4  *      guts of a UUID.
   5  *
   6  * Based on libuuid/src/uuid_time.c
   7  * Copyright (C) 1998, 1999 Theodore Ts'o.
   8  *
   9  * All alterations (C) 2017 Sami Kerola
  10  * The 3-Clause BSD License
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, and the entire permission notice in its entirety,
  17  *    including the disclaimer of warranties.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. The name of the author may not be used to endorse or promote
  22  *    products derived from this software without specific prior
  23  *    written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  26  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  27  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
  28  * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
  29  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  31  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  32  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  35  * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
  36  * DAMAGE.
  37  */
  38
  39 #include <assert.h>
  40 #include <getopt.h>
  41 #include <libsmartcols.h>
  42 #include <stdint.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <time.h>
  47 #include <unistd.h>
  48 #include <uuid.h>
  49
  50 #include "c.h"
  51 #include "closestream.h"
  52 #include "nls.h"
  53 #include "optutils.h"
  54 #include "strutils.h"
  55 #include "timeutils.h"
  56 #include "xalloc.h"
  57
  58 /* column IDs */
  59 enum {
  60         COL_UUID = 0,
  61         COL_VARIANT,
  62         COL_TYPE,
  63         COL_TIME
  64 };
  65
  66 /* column names */
  67 struct colinfo {
  68         const char *name;       /* header */
  69         double whint;           /* width hint (N < 1 is in percent of termwidth) */
  70         int flags;              /* SCOLS_FL_* */
  71         const char *help;
  72 };
  73
  74 /* columns descriptions */
  75 static const struct colinfo infos[] = {
  76         [COL_UUID]    = {"UUID",    UUID_STR_LEN, 0, N_("unique identifier")},
  77         [COL_VARIANT] = {"VARIANT", 9,  0, N_("variant name")},
  78         [COL_TYPE]    = {"TYPE",    10, 0, N_("type name")},
  79         [COL_TIME]    = {"TIME",    31, 0, N_("timestamp")}
  80 };
  81
  82 static int columns[ARRAY_SIZE(infos) * 2];
  83 static size_t ncolumns;
  84
  85 struct control {
  86         unsigned int
  87                 json:1,
  88                 no_headings:1,
  89                 raw:1;
  90 };
  91
  92 static void __attribute__((__noreturn__)) usage(void)
  93 {
  94         size_t i;
  95
  96         fputs(USAGE_HEADER, stdout);
  97         fprintf(stdout, _(" %s [options] <uuid ...>\n"), program_invocation_short_name);
  98
  99         fputs(USAGE_OPTIONS, stdout);
 100         fputsln(_(" -J, --json             use JSON output format"), stdout);
 101         fputsln(_(" -n, --noheadings       don't print headings"), stdout);
 102         fputsln(_(" -o, --output <list>    COLUMNS to display (see below)"), stdout);
 103         fputsln(_(" -r, --raw              use the raw output format"), stdout);
 104         fprintf(stdout, USAGE_HELP_OPTIONS(24));
 105
 106         fputs(USAGE_COLUMNS, stdout);
 107         for (i = 0; i < ARRAY_SIZE(infos); i++)
 108                 fprintf(stdout, " %8s  %s\n", infos[i].name, _(infos[i].help));
 109
 110         fprintf(stdout, USAGE_MAN_TAIL("uuidparse(1)"));
 111         exit(EXIT_SUCCESS);
 112 }
 113
 114 static int column_name_to_id(const char *name, size_t namesz)
 115 {
 116         size_t i;
 117
 118         assert(name);
 119
 120         for (i = 0; i < ARRAY_SIZE(infos); i++) {
 121                 const char *cn = infos[i].name;
 122                 if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
 123                         return i;
 124         }
 125         warnx(_("unknown column: %s"), name);
 126         return -1;
 127 }
 128
 129 static int get_column_id(size_t num)
 130 {
 131         assert(num < ncolumns);
 132         assert(columns[num] < (int)ARRAY_SIZE(infos));
 133         return columns[num];
 134 }
 135
 136 static const struct colinfo *get_column_info(int num)
 137 {
 138         return &infos[get_column_id(num)];
 139 }
 140
 141 static void fill_table_row(struct libscols_table *tb, char const *const uuid)
 142 {
 143         static struct libscols_line *ln;
 144         size_t i;
 145         uuid_t buf;
 146         int invalid = 0;
 147         int variant = -1, type = -1;
 148
 149         assert(tb);
 150         assert(uuid);
 151
 152         ln = scols_table_new_line(tb, NULL);
 153         if (!ln)
 154                 errx(EXIT_FAILURE, _("failed to allocate output line"));
 155
 156         if (uuid_parse(uuid, buf))
 157                 invalid = 1;
 158         else {
 159                 variant = uuid_variant(buf);
 160                 type = uuid_type(buf);
 161         }
 162
 163         for (i = 0; i < ncolumns; i++) {
 164                 char *str = NULL;
 165
 166                 switch (get_column_id(i)) {
 167                 case COL_UUID:
 168                         str = xstrdup(uuid);
 169                         break;
 170                 case COL_VARIANT:
 171                         if (invalid) {
 172                                 str = xstrdup(_("invalid"));
 173                                 break;
 174                         }
 175                         switch (variant) {
 176                         case UUID_VARIANT_NCS:
 177                                 str = xstrdup("NCS");
 178                                 break;
 179                         case UUID_VARIANT_DCE:
 180                                 str = xstrdup("DCE");
 181                                 break;
 182                         case UUID_VARIANT_MICROSOFT:
 183                                 str = xstrdup("Microsoft");
 184                                 break;
 185                         default:
 186                                 str = xstrdup(_("other"));
 187                         }
 188                         break;
 189                 case COL_TYPE:
 190                         if (invalid) {
 191                                 str = xstrdup(_("invalid"));
 192                                 break;
 193                         }
 194                         if (variant != UUID_VARIANT_DCE)
 195                                 break;
 196                         switch (type) {
 197                         case UUID_TYPE_DCE_NIL:
 198                                 if (uuid_is_null(buf))
 199                                         str = xstrdup(_("nil"));
 200                                 else
 201                                         str = xstrdup(_("unknown"));
 202                                 break;
 203                         case UUID_TYPE_DCE_TIME:
 204                                 str = xstrdup(_("time-based"));
 205                                 break;
 206                         case UUID_TYPE_DCE_SECURITY:
 207                                 str = xstrdup("DCE");
 208                                 break;
 209                         case UUID_TYPE_DCE_MD5:
 210                                 str = xstrdup(_("name-based"));
 211                                 break;
 212                         case UUID_TYPE_DCE_RANDOM:
 213                                 str = xstrdup(_("random"));
 214                                 break;
 215                         case UUID_TYPE_DCE_SHA1:
 216                                 str = xstrdup(_("sha1-based"));
 217                                 break;
 218                         default:
 219                                 str = xstrdup(_("unknown"));
 220                         }
 221                         break;
 222                 case COL_TIME:
 223                         if (invalid) {
 224                                 str = xstrdup(_("invalid"));
 225                                 break;
 226                         }
 227                         if (variant == UUID_VARIANT_DCE && type == UUID_TYPE_DCE_TIME) {
 228                                 struct timeval tv;
 229                                 char date_buf[ISO_BUFSIZ];
 230
 231                                 uuid_time(buf, &tv);
 232                                 strtimeval_iso(&tv, ISO_TIMESTAMP_COMMA,
 233                                                date_buf, sizeof(date_buf));
 234                                 str = xstrdup(date_buf);
 235                         }
 236                         break;
 237                 default:
 238                         abort();
 239                 }
 240                 if (str && scols_line_refer_data(ln, i, str))
 241                         errx(EXIT_FAILURE, _("failed to add output data"));
 242         }
 243 }
 244
 245 static void print_output(struct control const *const ctrl, int argc,
 246                          char **argv)
 247 {
 248         struct libscols_table *tb;
 249         size_t i;
 250
 251         scols_init_debug(0);
 252         tb = scols_new_table();
 253         if (!tb)
 254                 err(EXIT_FAILURE, _("failed to allocate output table"));
 255
 256         if (ctrl->json) {
 257                 scols_table_enable_json(tb, 1);
 258                 scols_table_set_name(tb, "uuids");
 259         }
 260         scols_table_enable_noheadings(tb, ctrl->no_headings);
 261         scols_table_enable_raw(tb, ctrl->raw);
 262
 263         for (i = 0; i < ncolumns; i++) {
 264                 const struct colinfo *col = get_column_info(i);
 265
 266                 if (!scols_table_new_column(tb, col->name, col->whint,
 267                                             col->flags))
 268                         err(EXIT_FAILURE,
 269                             _("failed to initialize output column"));
 270         }
 271
 272         for (i = 0; i < (size_t) argc; i++)
 273                 fill_table_row(tb, argv[i]);
 274
 275         if (i == 0) {
 276                 char uuid[UUID_STR_LEN];
 277
 278                 while (scanf(" %36[^ \t\n]%*c", uuid) && !feof(stdin))
 279                         fill_table_row(tb, uuid);
 280         }
 281         scols_print_table(tb);
 282         scols_unref_table(tb);
 283 }
 284
 285 int main(int argc, char **argv)
 286 {
 287         struct control ctrl = { 0 };
 288         char *outarg = NULL;
 289         int c;
 290
 291         static const struct option longopts[] = {
 292                 {"json",       no_argument,       NULL, 'J'},
 293                 {"noheadings", no_argument,       NULL, 'n'},
 294                 {"output",     required_argument, NULL, 'o'},
 295                 {"raw",        no_argument,       NULL, 'r'},
 296                 {"version",    no_argument,       NULL, 'V'},
 297                 {"help",       no_argument,       NULL, 'h'},
 298                 {NULL, 0, NULL, 0}
 299         };
 300         static const ul_excl_t excl[] = {
 301                 {'J', 'r'},
 302                 {0}
 303         };
 304         int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
 305
 306         setlocale(LC_ALL, "");
 307         bindtextdomain(PACKAGE, LOCALEDIR);
 308         textdomain(PACKAGE);
 309         close_stdout_atexit();
 310
 311         while ((c = getopt_long(argc, argv, "Jno:rVh", longopts, NULL)) != -1) {
 312                 err_exclusive_options(c, longopts, excl, excl_st);
 313                 switch (c) {
 314                 case 'J':
 315                         ctrl.json = 1;
 316                         break;
 317                 case 'n':
 318                         ctrl.no_headings = 1;
 319                         break;
 320                 case 'o':
 321                         outarg = optarg;
 322                         break;
 323                 case 'r':
 324                         ctrl.raw = 1;
 325                         break;
 326
 327                 case 'V':
 328                         print_version(EXIT_SUCCESS);
 329                 case 'h':
 330                         usage();
 331                 default:
 332                         errtryhelp(EXIT_FAILURE);
 333                 }
 334         }
 335         argc -= optind;
 336         argv += optind;
 337
 338         columns[ncolumns++] = COL_UUID;
 339         columns[ncolumns++] = COL_VARIANT;
 340         columns[ncolumns++] = COL_TYPE;
 341         columns[ncolumns++] = COL_TIME;
 342
 343         if (outarg
 344             && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
 345                                      &ncolumns, column_name_to_id) < 0)
 346                 return EXIT_FAILURE;
 347
 348         print_output(&ctrl, argc, argv);
 349
 350         return EXIT_SUCCESS;
 351 }