src/libsystemd/sd-id128/id128-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2016 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <unistd.h>
  24
  25 #include "fd-util.h"
  26 #include "hexdecoct.h"
  27 #include "id128-util.h"
  28 #include "io-util.h"
  29 #include "stdio-util.h"
  30
  31 char *id128_to_uuid_string(sd_id128_t id, char s[37]) {
  32         unsigned n, k = 0;
  33
  34         assert(s);
  35
  36         /* Similar to sd_id128_to_string() but formats the result as UUID instead of plain hex chars */
  37
  38         for (n = 0; n < 16; n++) {
  39
  40                 if (IN_SET(n, 4, 6, 8, 10))
  41                         s[k++] = '-';
  42
  43                 s[k++] = hexchar(id.bytes[n] >> 4);
  44                 s[k++] = hexchar(id.bytes[n] & 0xF);
  45         }
  46
  47         assert(k == 36);
  48
  49         s[k] = 0;
  50
  51         return s;
  52 }
  53
  54 bool id128_is_valid(const char *s) {
  55         size_t i, l;
  56
  57         assert(s);
  58
  59         l = strlen(s);
  60         if (l == 32) {
  61
  62                 /* Plain formatted 128bit hex string */
  63
  64                 for (i = 0; i < l; i++) {
  65                         char c = s[i];
  66
  67                         if (!(c >= '0' && c <= '9') &&
  68                             !(c >= 'a' && c <= 'z') &&
  69                             !(c >= 'A' && c <= 'Z'))
  70                                 return false;
  71                 }
  72
  73         } else if (l == 36) {
  74
  75                 /* Formatted UUID */
  76
  77                 for (i = 0; i < l; i++) {
  78                         char c = s[i];
  79
  80                         if (IN_SET(i, 8, 13, 18, 23)) {
  81                                 if (c != '-')
  82                                         return false;
  83                         } else {
  84                                 if (!(c >= '0' && c <= '9') &&
  85                                     !(c >= 'a' && c <= 'z') &&
  86                                     !(c >= 'A' && c <= 'Z'))
  87                                         return false;
  88                         }
  89                 }
  90
  91         } else
  92                 return false;
  93
  94         return true;
  95 }
  96
  97 int id128_read_fd(int fd, Id128Format f, sd_id128_t *ret) {
  98         char buffer[36 + 2];
  99         ssize_t l;
 100
 101         assert(fd >= 0);
 102         assert(f < _ID128_FORMAT_MAX);
 103
 104         /* Reads an 128bit ID from a file, which may either be in plain format (32 hex digits), or in UUID format, both
 105          * optionally followed by a newline and nothing else. ID files should really be newline terminated, but if they
 106          * aren't that's OK too, following the rule of "Be conservative in what you send, be liberal in what you
 107          * accept". */
 108
 109         l = loop_read(fd, buffer, sizeof(buffer), false); /* we expect a short read of either 32/33 or 36/37 chars */
 110         if (l < 0)
 111                 return (int) l;
 112         if (l == 0) /* empty? */
 113                 return -ENOMEDIUM;
 114
 115         switch (l) {
 116
 117         case 33: /* plain UUID with trailing newline */
 118                 if (buffer[32] != '\n')
 119                         return -EINVAL;
 120
 121                 _fallthrough_;
 122         case 32: /* plain UUID without trailing newline */
 123                 if (f == ID128_UUID)
 124                         return -EINVAL;
 125
 126                 buffer[32] = 0;
 127                 break;
 128
 129         case 37: /* RFC UUID with trailing newline */
 130                 if (buffer[36] != '\n')
 131                         return -EINVAL;
 132
 133                 _fallthrough_;
 134         case 36: /* RFC UUID without trailing newline */
 135                 if (f == ID128_PLAIN)
 136                         return -EINVAL;
 137
 138                 buffer[36] = 0;
 139                 break;
 140
 141         default:
 142                 return -EINVAL;
 143         }
 144
 145         return sd_id128_from_string(buffer, ret);
 146 }
 147
 148 int id128_read(const char *p, Id128Format f, sd_id128_t *ret) {
 149         _cleanup_close_ int fd = -1;
 150
 151         fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY);
 152         if (fd < 0)
 153                 return -errno;
 154
 155         return id128_read_fd(fd, f, ret);
 156 }
 157
 158 int id128_write_fd(int fd, Id128Format f, sd_id128_t id, bool do_sync) {
 159         char buffer[36 + 2];
 160         size_t sz;
 161         int r;
 162
 163         assert(fd >= 0);
 164         assert(f < _ID128_FORMAT_MAX);
 165
 166         if (f != ID128_UUID) {
 167                 sd_id128_to_string(id, buffer);
 168                 buffer[32] = '\n';
 169                 sz = 33;
 170         } else {
 171                 id128_to_uuid_string(id, buffer);
 172                 buffer[36] = '\n';
 173                 sz = 37;
 174         }
 175
 176         r = loop_write(fd, buffer, sz, false);
 177         if (r < 0)
 178                 return r;
 179
 180         if (do_sync) {
 181                 if (fsync(fd) < 0)
 182                         return -errno;
 183         }
 184
 185         return r;
 186 }
 187
 188 int id128_write(const char *p, Id128Format f, sd_id128_t id, bool do_sync) {
 189         _cleanup_close_ int fd = -1;
 190
 191         fd = open(p, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_TRUNC, 0444);
 192         if (fd < 0)
 193                 return -errno;
 194
 195         return id128_write_fd(fd, f, id, do_sync);
 196 }
 197
 198 void id128_hash_func(const void *p, struct siphash *state) {
 199         siphash24_compress(p, 16, state);
 200 }
 201
 202 int id128_compare_func(const void *a, const void *b) {
 203         return memcmp(a, b, 16);
 204 }
 205
 206 const struct hash_ops id128_hash_ops = {
 207         .hash = id128_hash_func,
 208         .compare = id128_compare_func,
 209 };