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'); }