chiark / gitweb /
Prep v233: Unmask now needed functions in src/basic
[elogind.git] / src / basic / hexdecoct.c
1 /***
2   This file is part of systemd.
3
4   Copyright 2010 Lennart Poettering
5
6   systemd is free software; you can redistribute it and/or modify it
7   under the terms of the GNU Lesser General Public License as published by
8   the Free Software Foundation; either version 2.1 of the License, or
9   (at your option) any later version.
10
11   systemd is distributed in the hope that it will be useful, but
12   WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   Lesser General Public License for more details.
15
16   You should have received a copy of the GNU Lesser General Public License
17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
18 ***/
19
20 #include <ctype.h>
21 #include <errno.h>
22 #include <stdint.h>
23 #include <stdlib.h>
24
25 #include "alloc-util.h"
26 #include "hexdecoct.h"
27 #include "macro.h"
28 #include "util.h"
29
30 char octchar(int x) {
31         return '0' + (x & 7);
32 }
33
34 int unoctchar(char c) {
35
36         if (c >= '0' && c <= '7')
37                 return c - '0';
38
39         return -EINVAL;
40 }
41
42 char decchar(int x) {
43         return '0' + (x % 10);
44 }
45
46 int undecchar(char c) {
47
48         if (c >= '0' && c <= '9')
49                 return c - '0';
50
51         return -EINVAL;
52 }
53
54 char hexchar(int x) {
55         static const char table[16] = "0123456789abcdef";
56
57         return table[x & 15];
58 }
59
60 int unhexchar(char c) {
61
62         if (c >= '0' && c <= '9')
63                 return c - '0';
64
65         if (c >= 'a' && c <= 'f')
66                 return c - 'a' + 10;
67
68         if (c >= 'A' && c <= 'F')
69                 return c - 'A' + 10;
70
71         return -EINVAL;
72 }
73
74 char *hexmem(const void *p, size_t l) {
75         const uint8_t *x;
76         char *r, *z;
77
78         z = r = new(char, l * 2 + 1);
79         if (!r)
80                 return NULL;
81
82         for (x = p; x < (const uint8_t*) p + l; x++) {
83                 *(z++) = hexchar(*x >> 4);
84                 *(z++) = hexchar(*x & 15);
85         }
86
87         *z = 0;
88         return r;
89 }
90
91 int unhexmem(const char *p, size_t l, void **mem, size_t *len) {
92         _cleanup_free_ uint8_t *r = NULL;
93         uint8_t *z;
94         const char *x;
95
96         assert(mem);
97         assert(len);
98         assert(p);
99
100         if (l % 2 != 0)
101                 return -EINVAL;
102
103         z = r = malloc((l + 1) / 2 + 1);
104         if (!r)
105                 return -ENOMEM;
106
107         for (x = p; x < p + l; x += 2) {
108                 int a, b;
109
110                 a = unhexchar(x[0]);
111                 if (a < 0)
112                         return a;
113
114                 b = unhexchar(x[1]);
115                 if (b < 0)
116                         return b;
117
118                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
119         }
120
121         *z = 0;
122
123         *mem = r;
124         r = NULL;
125         *len = (l + 1) / 2;
126
127         return 0;
128 }
129
130 /* https://tools.ietf.org/html/rfc4648#section-6
131  * Notice that base32hex differs from base32 in the alphabet it uses.
132  * The distinction is that the base32hex representation preserves the
133  * order of the underlying data when compared as bytestrings, this is
134  * useful when representing NSEC3 hashes, as one can then verify the
135  * order of hashes directly from their representation. */
136 char base32hexchar(int x) {
137         static const char table[32] = "0123456789"
138                                       "ABCDEFGHIJKLMNOPQRSTUV";
139
140         return table[x & 31];
141 }
142
143 int unbase32hexchar(char c) {
144         unsigned offset;
145
146         if (c >= '0' && c <= '9')
147                 return c - '0';
148
149         offset = '9' - '0' + 1;
150
151         if (c >= 'A' && c <= 'V')
152                 return c - 'A' + offset;
153
154         return -EINVAL;
155 }
156
157 char *base32hexmem(const void *p, size_t l, bool padding) {
158         char *r, *z;
159         const uint8_t *x;
160         size_t len;
161
162         if (padding)
163                 /* five input bytes makes eight output bytes, padding is added so we must round up */
164                 len = 8 * (l + 4) / 5;
165         else {
166                 /* same, but round down as there is no padding */
167                 len = 8 * l / 5;
168
169                 switch (l % 5) {
170                 case 4:
171                         len += 7;
172                         break;
173                 case 3:
174                         len += 5;
175                         break;
176                 case 2:
177                         len += 4;
178                         break;
179                 case 1:
180                         len += 2;
181                         break;
182                 }
183         }
184
185         z = r = malloc(len + 1);
186         if (!r)
187                 return NULL;
188
189         for (x = p; x < (const uint8_t*) p + (l / 5) * 5; x += 5) {
190                 /* x[0] == XXXXXXXX; x[1] == YYYYYYYY; x[2] == ZZZZZZZZ
191                    x[3] == QQQQQQQQ; x[4] == WWWWWWWW */
192                 *(z++) = base32hexchar(x[0] >> 3);                    /* 000XXXXX */
193                 *(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6);  /* 000XXXYY */
194                 *(z++) = base32hexchar((x[1] & 63) >> 1);             /* 000YYYYY */
195                 *(z++) = base32hexchar((x[1] & 1) << 4 | x[2] >> 4);  /* 000YZZZZ */
196                 *(z++) = base32hexchar((x[2] & 15) << 1 | x[3] >> 7); /* 000ZZZZQ */
197                 *(z++) = base32hexchar((x[3] & 127) >> 2);            /* 000QQQQQ */
198                 *(z++) = base32hexchar((x[3] & 3) << 3 | x[4] >> 5);  /* 000QQWWW */
199                 *(z++) = base32hexchar((x[4] & 31));                  /* 000WWWWW */
200         }
201
202         switch (l % 5) {
203         case 4:
204                 *(z++) = base32hexchar(x[0] >> 3);                    /* 000XXXXX */
205                 *(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6);  /* 000XXXYY */
206                 *(z++) = base32hexchar((x[1] & 63) >> 1);             /* 000YYYYY */
207                 *(z++) = base32hexchar((x[1] & 1) << 4 | x[2] >> 4);   /* 000YZZZZ */
208                 *(z++) = base32hexchar((x[2] & 15) << 1 | x[3] >> 7); /* 000ZZZZQ */
209                 *(z++) = base32hexchar((x[3] & 127) >> 2);            /* 000QQQQQ */
210                 *(z++) = base32hexchar((x[3] & 3) << 3);              /* 000QQ000 */
211                 if (padding)
212                         *(z++) = '=';
213
214                 break;
215
216         case 3:
217                 *(z++) = base32hexchar(x[0] >> 3);                   /* 000XXXXX */
218                 *(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */
219                 *(z++) = base32hexchar((x[1] & 63) >> 1);            /* 000YYYYY */
220                 *(z++) = base32hexchar((x[1] & 1) << 4 | x[2] >> 4); /* 000YZZZZ */
221                 *(z++) = base32hexchar((x[2] & 15) << 1);            /* 000ZZZZ0 */
222                 if (padding) {
223                         *(z++) = '=';
224                         *(z++) = '=';
225                         *(z++) = '=';
226                 }
227
228                 break;
229
230         case 2:
231                 *(z++) = base32hexchar(x[0] >> 3);                   /* 000XXXXX */
232                 *(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */
233                 *(z++) = base32hexchar((x[1] & 63) >> 1);            /* 000YYYYY */
234                 *(z++) = base32hexchar((x[1] & 1) << 4);             /* 000Y0000 */
235                 if (padding) {
236                         *(z++) = '=';
237                         *(z++) = '=';
238                         *(z++) = '=';
239                         *(z++) = '=';
240                 }
241
242                 break;
243
244         case 1:
245                 *(z++) = base32hexchar(x[0] >> 3);       /* 000XXXXX */
246                 *(z++) = base32hexchar((x[0] & 7) << 2); /* 000XXX00 */
247                 if (padding) {
248                         *(z++) = '=';
249                         *(z++) = '=';
250                         *(z++) = '=';
251                         *(z++) = '=';
252                         *(z++) = '=';
253                         *(z++) = '=';
254                 }
255
256                 break;
257         }
258
259         *z = 0;
260         return r;
261 }
262
263 int unbase32hexmem(const char *p, size_t l, bool padding, void **mem, size_t *_len) {
264         _cleanup_free_ uint8_t *r = NULL;
265         int a, b, c, d, e, f, g, h;
266         uint8_t *z;
267         const char *x;
268         size_t len;
269         unsigned pad = 0;
270
271         assert(p);
272
273         /* padding ensures any base32hex input has input divisible by 8 */
274         if (padding && l % 8 != 0)
275                 return -EINVAL;
276
277         if (padding) {
278                 /* strip the padding */
279                 while (l > 0 && p[l - 1] == '=' && pad < 7) {
280                         pad++;
281                         l--;
282                 }
283         }
284
285         /* a group of eight input bytes needs five output bytes, in case of
286            padding we need to add some extra bytes */
287         len = (l / 8) * 5;
288
289         switch (l % 8) {
290         case 7:
291                 len += 4;
292                 break;
293         case 5:
294                 len += 3;
295                 break;
296         case 4:
297                 len += 2;
298                 break;
299         case 2:
300                 len += 1;
301                 break;
302         case 0:
303                 break;
304         default:
305                 return -EINVAL;
306         }
307
308         z = r = malloc(len + 1);
309         if (!r)
310                 return -ENOMEM;
311
312         for (x = p; x < p + (l / 8) * 8; x += 8) {
313                 /* a == 000XXXXX; b == 000YYYYY; c == 000ZZZZZ; d == 000WWWWW
314                    e == 000SSSSS; f == 000QQQQQ; g == 000VVVVV; h == 000RRRRR */
315                 a = unbase32hexchar(x[0]);
316                 if (a < 0)
317                         return -EINVAL;
318
319                 b = unbase32hexchar(x[1]);
320                 if (b < 0)
321                         return -EINVAL;
322
323                 c = unbase32hexchar(x[2]);
324                 if (c < 0)
325                         return -EINVAL;
326
327                 d = unbase32hexchar(x[3]);
328                 if (d < 0)
329                         return -EINVAL;
330
331                 e = unbase32hexchar(x[4]);
332                 if (e < 0)
333                         return -EINVAL;
334
335                 f = unbase32hexchar(x[5]);
336                 if (f < 0)
337                         return -EINVAL;
338
339                 g = unbase32hexchar(x[6]);
340                 if (g < 0)
341                         return -EINVAL;
342
343                 h = unbase32hexchar(x[7]);
344                 if (h < 0)
345                         return -EINVAL;
346
347                 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2;                    /* XXXXXYYY */
348                 *(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */
349                 *(z++) = (uint8_t) d << 4 | (uint8_t) e >> 1;                    /* WWWWSSSS */
350                 *(z++) = (uint8_t) e << 7 | (uint8_t) f << 2 | (uint8_t) g >> 3; /* SQQQQQVV */
351                 *(z++) = (uint8_t) g << 5 | (uint8_t) h;                         /* VVVRRRRR */
352         }
353
354         switch (l % 8) {
355         case 7:
356                 a = unbase32hexchar(x[0]);
357                 if (a < 0)
358                         return -EINVAL;
359
360                 b = unbase32hexchar(x[1]);
361                 if (b < 0)
362                         return -EINVAL;
363
364                 c = unbase32hexchar(x[2]);
365                 if (c < 0)
366                         return -EINVAL;
367
368                 d = unbase32hexchar(x[3]);
369                 if (d < 0)
370                         return -EINVAL;
371
372                 e = unbase32hexchar(x[4]);
373                 if (e < 0)
374                         return -EINVAL;
375
376                 f = unbase32hexchar(x[5]);
377                 if (f < 0)
378                         return -EINVAL;
379
380                 g = unbase32hexchar(x[6]);
381                 if (g < 0)
382                         return -EINVAL;
383
384                 /* g == 000VV000 */
385                 if (g & 7)
386                         return -EINVAL;
387
388                 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2;                    /* XXXXXYYY */
389                 *(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */
390                 *(z++) = (uint8_t) d << 4 | (uint8_t) e >> 1;                    /* WWWWSSSS */
391                 *(z++) = (uint8_t) e << 7 | (uint8_t) f << 2 | (uint8_t) g >> 3; /* SQQQQQVV */
392
393                 break;
394         case 5:
395                 a = unbase32hexchar(x[0]);
396                 if (a < 0)
397                         return -EINVAL;
398
399                 b = unbase32hexchar(x[1]);
400                 if (b < 0)
401                         return -EINVAL;
402
403                 c = unbase32hexchar(x[2]);
404                 if (c < 0)
405                         return -EINVAL;
406
407                 d = unbase32hexchar(x[3]);
408                 if (d < 0)
409                         return -EINVAL;
410
411                 e = unbase32hexchar(x[4]);
412                 if (e < 0)
413                         return -EINVAL;
414
415                 /* e == 000SSSS0 */
416                 if (e & 1)
417                         return -EINVAL;
418
419                 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2;                    /* XXXXXYYY */
420                 *(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */
421                 *(z++) = (uint8_t) d << 4 | (uint8_t) e >> 1;                    /* WWWWSSSS */
422
423                 break;
424         case 4:
425                 a = unbase32hexchar(x[0]);
426                 if (a < 0)
427                         return -EINVAL;
428
429                 b = unbase32hexchar(x[1]);
430                 if (b < 0)
431                         return -EINVAL;
432
433                 c = unbase32hexchar(x[2]);
434                 if (c < 0)
435                         return -EINVAL;
436
437                 d = unbase32hexchar(x[3]);
438                 if (d < 0)
439                         return -EINVAL;
440
441                 /* d == 000W0000 */
442                 if (d & 15)
443                         return -EINVAL;
444
445                 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2;                    /* XXXXXYYY */
446                 *(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */
447
448                 break;
449         case 2:
450                 a = unbase32hexchar(x[0]);
451                 if (a < 0)
452                         return -EINVAL;
453
454                 b = unbase32hexchar(x[1]);
455                 if (b < 0)
456                         return -EINVAL;
457
458                 /* b == 000YYY00 */
459                 if (b & 3)
460                         return -EINVAL;
461
462                 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */
463
464                 break;
465         case 0:
466                 break;
467         default:
468                 return -EINVAL;
469         }
470
471         *z = 0;
472
473         *mem = r;
474         r = NULL;
475         *_len = len;
476
477         return 0;
478 }
479
480 /* https://tools.ietf.org/html/rfc4648#section-4 */
481 char base64char(int x) {
482         static const char table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
483                                       "abcdefghijklmnopqrstuvwxyz"
484                                       "0123456789+/";
485         return table[x & 63];
486 }
487
488 int unbase64char(char c) {
489         unsigned offset;
490
491         if (c >= 'A' && c <= 'Z')
492                 return c - 'A';
493
494         offset = 'Z' - 'A' + 1;
495
496         if (c >= 'a' && c <= 'z')
497                 return c - 'a' + offset;
498
499         offset += 'z' - 'a' + 1;
500
501         if (c >= '0' && c <= '9')
502                 return c - '0' + offset;
503
504         offset += '9' - '0' + 1;
505
506         if (c == '+')
507                 return offset;
508
509         offset++;
510
511         if (c == '/')
512                 return offset;
513
514         return -EINVAL;
515 }
516
517 ssize_t base64mem(const void *p, size_t l, char **out) {
518         char *r, *z;
519         const uint8_t *x;
520
521         /* three input bytes makes four output bytes, padding is added so we must round up */
522         z = r = malloc(4 * (l + 2) / 3 + 1);
523         if (!r)
524                 return -ENOMEM;
525
526         for (x = p; x < (const uint8_t*) p + (l / 3) * 3; x += 3) {
527                 /* x[0] == XXXXXXXX; x[1] == YYYYYYYY; x[2] == ZZZZZZZZ */
528                 *(z++) = base64char(x[0] >> 2);                    /* 00XXXXXX */
529                 *(z++) = base64char((x[0] & 3) << 4 | x[1] >> 4);  /* 00XXYYYY */
530                 *(z++) = base64char((x[1] & 15) << 2 | x[2] >> 6); /* 00YYYYZZ */
531                 *(z++) = base64char(x[2] & 63);                    /* 00ZZZZZZ */
532         }
533
534         switch (l % 3) {
535         case 2:
536                 *(z++) = base64char(x[0] >> 2);                   /* 00XXXXXX */
537                 *(z++) = base64char((x[0] & 3) << 4 | x[1] >> 4); /* 00XXYYYY */
538                 *(z++) = base64char((x[1] & 15) << 2);            /* 00YYYY00 */
539                 *(z++) = '=';
540
541                 break;
542         case 1:
543                 *(z++) = base64char(x[0] >> 2);        /* 00XXXXXX */
544                 *(z++) = base64char((x[0] & 3) << 4);  /* 00XX0000 */
545                 *(z++) = '=';
546                 *(z++) = '=';
547
548                 break;
549         }
550
551         *z = 0;
552         *out = r;
553         return z - r;
554 }
555
556 static int base64_append_width(char **prefix, int plen,
557                                const char *sep, int indent,
558                                const void *p, size_t l,
559                                int width) {
560
561         _cleanup_free_ char *x = NULL;
562         char *t, *s;
563         ssize_t slen, len, avail;
564         int line, lines;
565
566         len = base64mem(p, l, &x);
567         if (len <= 0)
568                 return len;
569
570         lines = (len + width - 1) / width;
571
572         slen = sep ? strlen(sep) : 0;
573         t = realloc(*prefix, plen + 1 + slen + (indent + width + 1) * lines);
574         if (!t)
575                 return -ENOMEM;
576
577         memcpy_safe(t + plen, sep, slen);
578
579         for (line = 0, s = t + plen + slen, avail = len; line < lines; line++) {
580                 int act = MIN(width, avail);
581
582                 if (line > 0 || sep) {
583                         memset(s, ' ', indent);
584                         s += indent;
585                 }
586
587                 memcpy(s, x + width * line, act);
588                 s += act;
589                 *(s++) = line < lines - 1 ? '\n' : '\0';
590                 avail -= act;
591         }
592         assert(avail == 0);
593
594         *prefix = t;
595         return 0;
596 }
597
598 int base64_append(char **prefix, int plen,
599                   const void *p, size_t l,
600                   int indent, int width) {
601         if (plen > width / 2 || plen + indent > width)
602                 /* leave indent on the left, keep last column free */
603                 return base64_append_width(prefix, plen, "\n", indent, p, l, width - indent - 1);
604         else
605                 /* leave plen on the left, keep last column free */
606                 return base64_append_width(prefix, plen, NULL, plen, p, l, width - plen - 1);
607 };
608
609
610 int unbase64mem(const char *p, size_t l, void **mem, size_t *_len) {
611         _cleanup_free_ uint8_t *r = NULL;
612         int a, b, c, d;
613         uint8_t *z;
614         const char *x;
615         size_t len;
616
617         assert(p);
618
619         /* padding ensures any base63 input has input divisible by 4 */
620         if (l % 4 != 0)
621                 return -EINVAL;
622
623         /* strip the padding */
624         if (l > 0 && p[l - 1] == '=')
625                 l--;
626         if (l > 0 && p[l - 1] == '=')
627                 l--;
628
629         /* a group of four input bytes needs three output bytes, in case of
630            padding we need to add two or three extra bytes */
631         len = (l / 4) * 3 + (l % 4 ? (l % 4) - 1 : 0);
632
633         z = r = malloc(len + 1);
634         if (!r)
635                 return -ENOMEM;
636
637         for (x = p; x < p + (l / 4) * 4; x += 4) {
638                 /* a == 00XXXXXX; b == 00YYYYYY; c == 00ZZZZZZ; d == 00WWWWWW */
639                 a = unbase64char(x[0]);
640                 if (a < 0)
641                         return -EINVAL;
642
643                 b = unbase64char(x[1]);
644                 if (b < 0)
645                         return -EINVAL;
646
647                 c = unbase64char(x[2]);
648                 if (c < 0)
649                         return -EINVAL;
650
651                 d = unbase64char(x[3]);
652                 if (d < 0)
653                         return -EINVAL;
654
655                 *(z++) = (uint8_t) a << 2 | (uint8_t) b >> 4; /* XXXXXXYY */
656                 *(z++) = (uint8_t) b << 4 | (uint8_t) c >> 2; /* YYYYZZZZ */
657                 *(z++) = (uint8_t) c << 6 | (uint8_t) d;      /* ZZWWWWWW */
658         }
659
660         switch (l % 4) {
661         case 3:
662                 a = unbase64char(x[0]);
663                 if (a < 0)
664                         return -EINVAL;
665
666                 b = unbase64char(x[1]);
667                 if (b < 0)
668                         return -EINVAL;
669
670                 c = unbase64char(x[2]);
671                 if (c < 0)
672                         return -EINVAL;
673
674                 /* c == 00ZZZZ00 */
675                 if (c & 3)
676                         return -EINVAL;
677
678                 *(z++) = (uint8_t) a << 2 | (uint8_t) b >> 4; /* XXXXXXYY */
679                 *(z++) = (uint8_t) b << 4 | (uint8_t) c >> 2; /* YYYYZZZZ */
680
681                 break;
682         case 2:
683                 a = unbase64char(x[0]);
684                 if (a < 0)
685                         return -EINVAL;
686
687                 b = unbase64char(x[1]);
688                 if (b < 0)
689                         return -EINVAL;
690
691                 /* b == 00YY0000 */
692                 if (b & 15)
693                         return -EINVAL;
694
695                 *(z++) = (uint8_t) a << 2 | (uint8_t) (b >> 4); /* XXXXXXYY */
696
697                 break;
698         case 0:
699
700                 break;
701         default:
702                 return -EINVAL;
703         }
704
705         *z = 0;
706
707         *mem = r;
708         r = NULL;
709         *_len = len;
710
711         return 0;
712 }
713
714 void hexdump(FILE *f, const void *p, size_t s) {
715         const uint8_t *b = p;
716         unsigned n = 0;
717
718         assert(s == 0 || b);
719
720         while (s > 0) {
721                 size_t i;
722
723                 fprintf(f, "%04x  ", n);
724
725                 for (i = 0; i < 16; i++) {
726
727                         if (i >= s)
728                                 fputs("   ", f);
729                         else
730                                 fprintf(f, "%02x ", b[i]);
731
732                         if (i == 7)
733                                 fputc(' ', f);
734                 }
735
736                 fputc(' ', f);
737
738                 for (i = 0; i < 16; i++) {
739
740                         if (i >= s)
741                                 fputc(' ', f);
742                         else
743                                 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
744                 }
745
746                 fputc('\n', f);
747
748                 if (s < 16)
749                         break;
750
751                 n += 16;
752                 b += 16;
753                 s -= 16;
754         }
755 }