int
escape(const char *src, unsigned int slen, char **dstp)
{
char *dst;
size_t dlen;
size_t i;
if (!slen)
slen = (int)strlen(src);
for (i = 0, dlen = 0; i < slen; i++)
if (PASSTHRU(src[i]))
dlen++;
else
dlen += 4;
if (!(dst = malloc(dlen + 1)))
return 0;
for (i = 0, dlen = 0; i < slen; i++)
if (!PASSTHRU(src[i])) {
dst[dlen++] = '\\';
dst[dlen++] = 'x';
dst[dlen++] = hexchar((unsigned char)src[i] / 16);
dst[dlen++] = hexchar((unsigned char)src[i] % 16);
} else {
dst[dlen++] = src[i];
}
dst[dlen++] = 0;
*dstp = dst;
return 1;
}
static void param_handler(const char *key, const char *value, void *arg)
{
list_t *list = arg;
param_t *param;
int i, j, l;
assert(key);
assert(value);
assert(list);
param = malloc(sizeof(*param));
// FIX: need to parse the key to replace meta chars.
l = strlen(key);
param->key = malloc(l);
for (i=0,j=0; i<l; i++,j++) {
if (key[i] == '%' && i+2<l) {
param->key[j] = hexchar(&key[i+1]);
i += 2;
}
else if (key[i] == '+') {
param->key[j] = ' ';
}
else {
param->key[j] = key[i];
}
}
param->key[j] = 0;
// FIX: need to parse the value to replace the meta chars..
l = strlen(value);
param->value = malloc(l+1);
for (i=0,j=0; i<l; i++,j++) {
if (value[i] == '%' && i+2<l) {
param->value[j] = hexchar(&value[i+1]);
i += 2;
}
else if (value[i] == '+') {
param->value[j] = ' ';
}
else {
param->value[j] = value[i];
}
}
param->value[j] = 0;
// printf("key: '%s', value: '%s' \n", param->key, param->value);
ll_push_tail(list, param);
}
bool ID12LA::crc_ok()
{
byte chk_ref = hexchar(buf_[10]) * 16 + hexchar(buf_[11]);
byte chk = 0;
for (int i = 0; i < 5; i++) {
char *hex = &buf_[i*2];
byte data = hexchar(hex[0]) * 16 + hexchar(hex[1]);
chk ^= data;
}
return chk == chk_ref;
}
int hexdecode(unsigned char* bytes, const char* hex, unsigned int nbytes) {
if (strlen(hex) != nbytes * 2) {
return -1;
}
unsigned int i;
for (i = 0; i < nbytes; i++) {
int hi = hexchar(hex[2 * i]), lo = hexchar(hex[2 * i + 1]);
if (hi < 0 || lo < 0)
return -1;
bytes[i] = hi * 16 + lo;
}
return 0;
}
bool
fill_txt(const char *src, size_t len, size_t olen)
{
char *dst;
int h;
debug_decl(fill_txt, SUDOERS_DEBUG_PARSER)
dst = olen ? realloc(sudoerslval.string, olen + len + 1) : malloc(len + 1);
if (dst == NULL) {
sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
sudoerserror(NULL);
debug_return_bool(false);
}
sudoerslval.string = dst;
/* Copy the string and collapse any escaped characters. */
dst += olen;
while (len--) {
if (*src == '\\' && len) {
if (src[1] == 'x' && len >= 3 && (h = hexchar(src + 2)) != -1) {
*dst++ = h;
src += 4;
len -= 3;
} else {
src++;
len--;
*dst++ = *src++;
}
} else {
*dst++ = *src++;
}
}
*dst = '\0';
debug_return_bool(true);
}
static int show_line(unsigned offset, const unsigned char *data,
unsigned size, int show_empty)
{
unsigned char bits;
int i, off;
char buffer[120];
if (size > 16)
size = 16;
bits = 0;
memset(buffer, ' ', sizeof(buffer));
off = sprintf(buffer, "%06x ", offset);
for (i = 0; i < size; i++) {
char *hex = buffer + off + 3 * i;
char *asc = buffer + off + 50 + i;
unsigned char byte = data[i];
hex[0] = hexchar(byte >> 4);
hex[1] = hexchar(byte);
bits |= byte;
if (byte < 32 || byte > 126)
byte = '.';
asc[0] = byte;
asc[1] = 0;
}
if (bits) {
puts(buffer);
return 1;
}
if (show_empty)
puts("...");
return 0;
}
//
// produce a (hex) string from binary data
// we (blindly) assume caller
// made page large enough!
//
// return actual number of characters written to page
//
int
format_hex(
char *page, // output: data displayed in hex
int size, // input: number of bytes in data
char *data // input: binary data
) {
int len; // number of characters written to page.
char *optr; // address within page
int k; // index into data: 0 .. size - 1
printk(KERN_DEBUG "vote: process %i (%s) in %s() \n",
current->pid, current->comm, __FUNCTION__);
optr = page;
len = sprintf(optr, "Hex: ");
optr += len;
// Traverse data, writing ascii hex digits to page.
for(k = 0; k < size; k++) {
optr = hexchar(optr, data[k]);
}
len = strlen(page);
return len;
} // format_hex()
static int scanch(void) {
int c, c2;
c = next();
if ('\\' == c) {
switch (c = next()) {
case 'a': return '\a';
case 'b': return '\b';
case 'f': return '\f';
case 'n': return '\n';
case 'r': return '\r';
case 't': return '\t';
case 'v': return '\v';
case '\\': return '\\';
case '"': return '"' | 256;
case '\'': return '\'';
case '0': case '1': case '2':
case '3': case '4': case '5':
case '6': case '7':
for (c2 = 0; isdigit(c) && c < '8'; c = next())
c2 = c2 * 8 + (c - '0');
putback(c);
return c2;
case 'x':
return hexchar();
default:
cerror("unknown escape sequence: %s", c);
return ' ';
}
}
else {
return c;
}
}
char *utf8_escape_non_printable(const char *str) {
char *p, *s;
assert(str);
p = s = malloc(strlen(str) * 4 + 1);
if (!p)
return NULL;
while (*str) {
int len;
len = utf8_encoded_valid_unichar(str);
if (len > 0) {
if (utf8_is_printable(str, len)) {
s = mempcpy(s, str, len);
str += len;
} else {
while (len > 0) {
*(s++) = '\\';
*(s++) = 'x';
*(s++) = hexchar((int) *str >> 4);
*(s++) = hexchar((int) *str);
str += 1;
len --;
}
}
} else {
s = stpcpy(s, UTF8_REPLACEMENT_CHARACTER);
str += 1;
}
}
// *** rprintfu04 ***
// prints an unsigned 4-bit number in hex (1 digit)
void rprintfu04(unsigned char data)
{
// print 4-bit hex value
// char Character = data&0x0f;
// if (Character>9)
// Character+='A'-10;
// else
// Character+='0';
rprintfChar(hexchar(data));
}
void nybbles(char *oData, unsigned char bsz, unsigned char const *value, unsigned char vsz)
{
if (vsz*2+1 > bsz) {
vsz = (bsz-1)/2;
}
while (vsz > 0) {
vsz--;
*oData++ = hexchar(*value >> 4);
*oData++ = hexchar(*value);
value++;
}
*oData = 0;
}
void format_value(void const *src, RegType type, unsigned char bufsz, char *oData)
{
*oData = 0;
unsigned char v = *(unsigned char *)src;
switch (type) {
default:
fatal(FATAL_BAD_ARGS);
case RegTypeUnknown:
return;
case RegTypeUchar:
if (bufsz < 3) return;
oData[0] = hexchar(v >> 4);
oData[1] = hexchar(v & 0xf);
oData[2] = 0;
return;
case RegTypeUchar16:
if (bufsz < 4) return;
oData[0] = hexchar(v >> 4);
oData[1] = '.';
oData[2] = hexchar(v & 0xf);
oData[3] = 0;
return;
case RegTypeSchar:
if (bufsz < 4) return;
if (v & 0x80) {
v = (v ^ ~0) + 1;
*oData++ = '-';
}
*oData++ = hexchar(v >> 4);
*oData++ = hexchar(v & 0xf);
*oData = 0;
return;
case RegTypeSshort:
case RegTypeUshort:
if (bufsz < 5) return;
nybbles(oData, 5, (unsigned char const *)src, 2);
return;
}
}
_public_ char *sd_id128_to_string(sd_id128_t id, char s[SD_ID128_STRING_MAX]) {
unsigned n;
assert_return(s, NULL);
for (n = 0; n < 16; n++) {
s[n*2] = hexchar(id.bytes[n] >> 4);
s[n*2+1] = hexchar(id.bytes[n] & 0xF);
}
s[32] = 0;
return s;
}
static int generate(char id[34]) {
int fd;
char buf[16];
char *p, *q;
ssize_t k;
assert(id);
/* First, try reading the D-Bus machine id, unless it is a symlink */
if ((fd = open("/var/lib/dbus/machine-id", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW)) >= 0) {
k = loop_read(fd, id, 33, false);
close_nointr_nofail(fd);
if (k >= 32) {
id[32] = '\n';
id[33] = 0;
log_info("Initializing machine ID from D-Bus machine ID.");
return 0;
}
}
/* If that didn't work, generate a random machine id */
if ((fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY)) < 0) {
log_error("Failed to open /dev/urandom: %m");
return -errno;
}
k = loop_read(fd, buf, sizeof(buf), false);
close_nointr_nofail(fd);
if (k != sizeof(buf)) {
log_error("Failed to read /dev/urandom: %s", strerror(k < 0 ? -k : EIO));
return k < 0 ? (int) k : -EIO;
}
for (p = buf, q = id; p < buf + sizeof(buf); p++, q += 2) {
q[0] = hexchar(*p >> 4);
q[1] = hexchar(*p & 15);
}
id[32] = '\n';
id[33] = 0;
log_info("Initializing machine ID from random generator.");
return 0;
}
_public_ char *sd_id128_to_string(sd_id128_t id, char s[33]) {
unsigned n;
if (!s)
return NULL;
for (n = 0; n < 16; n++) {
s[n*2] = hexchar(id.bytes[n] >> 4);
s[n*2+1] = hexchar(id.bytes[n] & 0xF);
}
s[32] = 0;
return s;
}
ULONG hex_to_binary( xmlChar *str, ULONG len, BYTE *buf )
{
unsigned int i, n;
BYTE msb, lsb;
i = 0;
n = 0;
while (str[i] && str[i+1])
{
msb = hexchar( str[i++] );
if (msb == 0xff)
break;
lsb = hexchar( str[i++] );
if (lsb == 0xff)
break;
if (buf)
buf[n] = (msb<<4) | lsb;
//trace("%02x ", (msb<<4) | lsb);
n++;
}
//trace("\n");
assert( len == 0 || n <= len );
return n;
}
static int hex_out(putchar_f f, void *ctx, uint64_t val)
{
unsigned char d[32];
unsigned int i = 0, r;
while (val) {
d[i++] = hexchar(val);
val >>= 4;
}
if (i == 0)
d[i++] = '0';
r = i;
while (i)
f(ctx, d[--i]);
return r;
}
bool hex_encode(const void *buf, size_t bufsize, char *dest, size_t destsize)
{
size_t used = 0;
if (destsize < 1)
return false;
while (used < bufsize) {
unsigned int c = ((const unsigned char *)buf)[used];
if (destsize < 3)
return false;
*(dest++) = hexchar(c >> 4);
*(dest++) = hexchar(c & 0xF);
used++;
destsize -= 2;
}
*dest = '\0';
return used + 1;
}
static int shorten_uuid(char destination[36], const char *source) {
unsigned i, j;
for (i = 0, j = 0; i < 36 && j < 32; i++) {
int t;
t = unhexchar(source[i]);
if (t < 0)
continue;
destination[j++] = hexchar(t);
}
if (i == 36 && j == 32) {
destination[32] = '\n';
destination[33] = 0;
return 0;
}
return -EINVAL;
}
char *id128_to_uuid_string(sd_id128_t id, char s[37]) {
unsigned n, k = 0;
assert(s);
/* Similar to sd_id128_to_string() but formats the result as UUID instead of plain hex chars */
for (n = 0; n < 16; n++) {
if (IN_SET(n, 4, 6, 8, 10))
s[k++] = '-';
s[k++] = hexchar(id.bytes[n] >> 4);
s[k++] = hexchar(id.bytes[n] & 0xF);
}
assert(k == 36);
s[k] = 0;
return s;
}
void number_to_binary( xmlChar *str, ULONG len, BYTE *buf )
{
char *valstr = (char*) str;
ULONG base = 0;
ULONG val = 0;
ULONG i;
BYTE ch;
if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
{
// hex
base = 0x10;
i = 2;
}
else if (str[0] == '0')
{
// octal
base = 8;
i = 1;
}
else
{
// decimal
base = 10;
i = 0;
}
while (str[i])
{
ch = hexchar(str[i]);
if (ch >= base)
die("invalid registry value %s\n", valstr);
val *= base;
val += ch;
i++;
}
*((ULONG*) buf) = val;
}
int dns_name_reverse(int family, const union in_addr_union *a, char **ret) {
const uint8_t *p;
int r;
assert(a);
assert(ret);
p = (const uint8_t*) a;
if (family == AF_INET)
r = asprintf(ret, "%u.%u.%u.%u.in-addr.arpa", p[3], p[2], p[1], p[0]);
else if (family == AF_INET6)
r = asprintf(ret, "%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.ip6.arpa",
hexchar(p[15] & 0xF), hexchar(p[15] >> 4), hexchar(p[14] & 0xF), hexchar(p[14] >> 4),
hexchar(p[13] & 0xF), hexchar(p[13] >> 4), hexchar(p[12] & 0xF), hexchar(p[12] >> 4),
hexchar(p[11] & 0xF), hexchar(p[11] >> 4), hexchar(p[10] & 0xF), hexchar(p[10] >> 4),
hexchar(p[ 9] & 0xF), hexchar(p[ 9] >> 4), hexchar(p[ 8] & 0xF), hexchar(p[ 8] >> 4),
hexchar(p[ 7] & 0xF), hexchar(p[ 7] >> 4), hexchar(p[ 6] & 0xF), hexchar(p[ 6] >> 4),
hexchar(p[ 5] & 0xF), hexchar(p[ 5] >> 4), hexchar(p[ 4] & 0xF), hexchar(p[ 4] >> 4),
hexchar(p[ 3] & 0xF), hexchar(p[ 3] >> 4), hexchar(p[ 2] & 0xF), hexchar(p[ 2] >> 4),
hexchar(p[ 1] & 0xF), hexchar(p[ 1] >> 4), hexchar(p[ 0] & 0xF), hexchar(p[ 0] >> 4));
else
return -EAFNOSUPPORT;
int
main (int argc, char **argv)
{
register long address;
char string[18];
FILE *fp;
progname = *argv++; --argc;
/*
** -hex hex dump
** -oct Octal dump
** -group-by-8-bits
** -group-by-16-bits
** -group-by-32-bits
** -group-by-64-bits
** -iso iso character set.
** -big-endian Big Endian
** -little-endian Little Endian
** -un || -de from hexl format to binary.
** -- End switch list.
** <filename> dump filename
** - (as filename == stdin)
*/
while (*argv && *argv[0] == '-' && (*argv)[1])
{
/* A switch! */
if (!strcmp (*argv, "--"))
{
--argc; argv++;
break;
}
else if (!strcmp (*argv, "-un") || !strcmp (*argv, "-de"))
{
un_flag = true;
--argc; argv++;
}
else if (!strcmp (*argv, "-hex"))
{
base = 16;
--argc; argv++;
}
else if (!strcmp (*argv, "-iso"))
{
iso_flag = true;
--argc; argv++;
}
else if (!strcmp (*argv, "-oct"))
{
base = 8;
--argc; argv++;
}
else if (!strcmp (*argv, "-big-endian"))
{
endian = true;
--argc; argv++;
}
else if (!strcmp (*argv, "-little-endian"))
{
endian = false;
--argc; argv++;
}
else if (!strcmp (*argv, "-group-by-8-bits"))
{
group_by = 0x00;
--argc; argv++;
}
else if (!strcmp (*argv, "-group-by-16-bits"))
{
group_by = 0x01;
--argc; argv++;
}
else if (!strcmp (*argv, "-group-by-32-bits"))
{
group_by = 0x03;
--argc; argv++;
}
else if (!strcmp (*argv, "-group-by-64-bits"))
{
group_by = 0x07;
endian = false;
--argc; argv++;
}
else
{
fprintf (stderr, "%s: invalid switch: \"%s\".\n", progname,
*argv);
usage ();
}
}
do
{
if (*argv == NULL)
fp = stdin;
else
{
char *filename = *argv++;
if (!strcmp (filename, "-"))
fp = stdin;
else if ((fp = fopen (filename, "r")) == NULL)
{
perror (filename);
continue;
}
}
if (un_flag)
{
char buf[18];
#ifdef DOS_NT
#if (__DJGPP__ >= 2) || (defined WINDOWSNT)
if (!isatty (fileno (stdout)))
setmode (fileno (stdout), O_BINARY);
#else
(stdout)->_flag &= ~_IOTEXT; /* print binary */
_setmode (fileno (stdout), O_BINARY);
#endif
#endif
for (;;)
{
register int i, c = 0, d;
#define hexchar(x) (isdigit (x) ? x - '0' : x - 'a' + 10)
/* Skip 10 bytes. */
if (fread (buf, 1, 10, fp) != 10)
break;
for (i=0; i < 16; ++i)
{
if ((c = getc (fp)) == ' ' || c == EOF)
break;
d = getc (fp);
c = hexchar (c) * 0x10 + hexchar (d);
putchar (c);
if ((i&group_by) == group_by)
getc (fp);
}
if (c == ' ')
{
while ((c = getc (fp)) != '\n' && c != EOF)
;
if (c == EOF)
break;
}
else
{
if (i < 16)
break;
/* Skip 18 bytes. */
if (fread (buf, 1, 18, fp) != 18)
break;
}
}
}
else
{
#ifdef DOS_NT
#if (__DJGPP__ >= 2) || (defined WINDOWSNT)
if (!isatty (fileno (fp)))
setmode (fileno (fp), O_BINARY);
#else
(fp)->_flag &= ~_IOTEXT; /* read binary */
_setmode (fileno (fp), O_BINARY);
#endif
#endif
address = 0;
string[0] = ' ';
string[17] = '\0';
for (;;)
{
register int i, c = 0;
for (i=0; i < 16; ++i)
{
if ((c = getc (fp)) == EOF)
{
if (!i)
break;
fputs (" ", stdout);
string[i+1] = '\0';
}
else
{
if (!i)
printf ("%08lx: ", address);
if (iso_flag)
string[i+1] =
(c < 0x20 || (c >= 0x7F && c < 0xa0)) ? '.' :c;
else
string[i+1] = (c < 0x20 || c >= 0x7F) ? '.' : c;
printf ("%02x", c);
}
if ((i&group_by) == group_by)
putchar (' ');
}
if (i)
puts (string);
if (c == EOF)
break;
address += 0x10;
}
}
if (fp != stdin)
fclose (fp);
} while (*argv != NULL);
return EXIT_SUCCESS;
}
int
main (int argc, char **argv)
{
int status = EXIT_SUCCESS;
int DEFAULT_GROUPING = 0x01;
int group_by = DEFAULT_GROUPING;
bool un_flag = false, iso_flag = false;
progname = *argv++;
/*
** -hex hex dump
** -group-by-8-bits
** -group-by-16-bits
** -group-by-32-bits
** -group-by-64-bits
** -iso iso character set.
** -un || -de from hexl format to binary.
** -- End switch list.
** <filename> dump filename
** - (as filename == stdin)
*/
for (; *argv && *argv[0] == '-' && (*argv)[1]; argv++)
{
/* A switch! */
if (!strcmp (*argv, "--"))
{
argv++;
break;
}
else if (!strcmp (*argv, "-un") || !strcmp (*argv, "-de"))
{
un_flag = true;
set_binary_mode (fileno (stdout), O_BINARY);
}
else if (!strcmp (*argv, "-hex"))
/* Hex is the default and is only base supported. */;
else if (!strcmp (*argv, "-iso"))
iso_flag = true;
else if (!strcmp (*argv, "-group-by-8-bits"))
group_by = 0x00;
else if (!strcmp (*argv, "-group-by-16-bits"))
group_by = 0x01;
else if (!strcmp (*argv, "-group-by-32-bits"))
group_by = 0x03;
else if (!strcmp (*argv, "-group-by-64-bits"))
group_by = 0x07;
else
{
fprintf (stderr, "%s: invalid switch: \"%s\".\n", progname,
*argv);
fprintf (stderr, "usage: %s [-de] [-iso]\n", progname);
return EXIT_FAILURE;
}
}
char const *filename = *argv ? *argv++ : "-";
do
{
FILE *fp;
if (!strcmp (filename, "-"))
{
fp = stdin;
if (!un_flag)
set_binary_mode (fileno (stdin), O_BINARY);
}
else
{
fp = fopen (filename, un_flag ? "r" : "rb");
if (!fp)
{
perror (filename);
status = EXIT_FAILURE;
continue;
}
}
if (un_flag)
{
for (int c; 0 <= (c = getc (fp)); )
{
/* Skip address at start of line. */
if (c != ' ')
continue;
for (int i = 0; i < 16; i++)
{
c = getc (fp);
if (c < 0 || c == ' ')
break;
int hc = hexchar (c);
c = getc (fp);
if (c < 0)
break;
putchar (hc * 0x10 + hexchar (c));
if ((i & group_by) == group_by)
{
c = getc (fp);
if (c < 0)
break;
}
}
while (0 <= c && c != '\n')
c = getc (fp);
if (c < 0)
break;
if (ferror (stdout))
output_error ();
}
}
else
{
int c = 0;
char string[18];
string[0] = ' ';
string[17] = '\0';
for (uintmax_t address = 0; 0 <= c; address += 0x10)
{
int i;
for (i = 0; i < 16; i++)
{
if (0 <= c)
c = getc (fp);
if (c < 0)
{
if (!i)
break;
fputs (" ", stdout);
string[i + 1] = '\0';
}
else
{
if (!i)
printf ("%08"PRIxMAX": ", address);
string[i + 1]
= (c < 0x20 || (0x7F <= c && (!iso_flag || c < 0xa0))
? '.' : c);
printf ("%02x", c + 0u);
}
if ((i & group_by) == group_by)
putchar (' ');
}
if (i)
puts (string);
if (ferror (stdout))
output_error ();
}
}
bool trouble = ferror (fp) != 0;
trouble |= fp != stdin && fclose (fp) != 0;
if (trouble)
{
fprintf (stderr, "%s: read error\n", progname);
status = EXIT_FAILURE;
}
filename = *argv++;
}
while (filename);
if (ferror (stdout) || fclose (stdout) != 0)
output_error ();
return status;
}
static int generate(char id[34]) {
int fd, r;
unsigned char *p;
sd_id128_t buf;
char *q;
ssize_t k;
const char *vm_id;
assert(id);
/* First, try reading the D-Bus machine id, unless it is a symlink */
fd = open("/var/lib/dbus/machine-id", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
if (fd >= 0) {
k = loop_read(fd, id, 32, false);
close_nointr_nofail(fd);
if (k >= 32) {
id[32] = '\n';
id[33] = 0;
log_info("Initializing machine ID from D-Bus machine ID.");
return 0;
}
}
/* If that didn't work, see if we are running in qemu/kvm and a
* machine ID was passed in via -uuid on the qemu/kvm command
* line */
r = detect_vm(&vm_id);
if (r > 0 && streq(vm_id, "kvm")) {
char uuid[37];
fd = open("/sys/class/dmi/id/product_uuid", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
if (fd >= 0) {
k = loop_read(fd, uuid, 36, false);
close_nointr_nofail(fd);
if (k >= 36) {
r = shorten_uuid(id, uuid);
if (r >= 0) {
log_info("Initializing machine ID from KVM UUID.");
return 0;
}
}
}
}
/* If that didn't work either, see if we are running in a
* container, and a machine ID was passed in via
* $container_uuid the way libvirt/LXC does it */
r = detect_container(NULL);
if (r > 0) {
char *e;
r = getenv_for_pid(1, "container_uuid", &e);
if (r > 0) {
if (strlen(e) >= 36) {
r = shorten_uuid(id, e);
if (r >= 0) {
log_info("Initializing machine ID from container UUID.");
free(e);
return 0;
}
}
free(e);
}
}
/* If that didn't work, generate a random machine id */
r = sd_id128_randomize(&buf);
if (r < 0) {
log_error("Failed to open /dev/urandom: %s", strerror(-r));
return r;
}
for (p = buf.bytes, q = id; p < buf.bytes + sizeof(buf); p++, q += 2) {
q[0] = hexchar(*p >> 4);
q[1] = hexchar(*p & 15);
}
id[32] = '\n';
id[33] = 0;
log_info("Initializing machine ID from random generator.");
return 0;
}
static void test_hexchar(void) {
assert_se(hexchar(0xa) == 'a');
assert_se(hexchar(0x0) == '0');
}
