Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * lib/hexdump.c
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License version 2 as
  6.  * published by the Free Software Foundation. See README and COPYING for
  7.  * more details.
  8.  */
  9.  
  10. #include <linux/types.h>
  11. #include <linux/ctype.h>
  12. #include <linux/kernel.h>
  13. #include <linux/export.h>
  14. #include <asm/unaligned.h>
  15.  
  16. const char hex_asc[] = "0123456789abcdef";
  17. EXPORT_SYMBOL(hex_asc);
  18. const char hex_asc_upper[] = "0123456789ABCDEF";
  19. EXPORT_SYMBOL(hex_asc_upper);
  20.  
  21. /**
  22.  * hex_to_bin - convert a hex digit to its real value
  23.  * @ch: ascii character represents hex digit
  24.  *
  25.  * hex_to_bin() converts one hex digit to its actual value or -1 in case of bad
  26.  * input.
  27.  */
  28. int hex_to_bin(char ch)
  29. {
  30.         if ((ch >= '0') && (ch <= '9'))
  31.                 return ch - '0';
  32.         ch = tolower(ch);
  33.         if ((ch >= 'a') && (ch <= 'f'))
  34.                 return ch - 'a' + 10;
  35.         return -1;
  36. }
  37. EXPORT_SYMBOL(hex_to_bin);
  38.  
  39. /**
  40.  * hex2bin - convert an ascii hexadecimal string to its binary representation
  41.  * @dst: binary result
  42.  * @src: ascii hexadecimal string
  43.  * @count: result length
  44.  *
  45.  * Return 0 on success, -1 in case of bad input.
  46.  */
  47. int hex2bin(u8 *dst, const char *src, size_t count)
  48. {
  49.         while (count--) {
  50.                 int hi = hex_to_bin(*src++);
  51.                 int lo = hex_to_bin(*src++);
  52.  
  53.                 if ((hi < 0) || (lo < 0))
  54.                         return -1;
  55.  
  56.                 *dst++ = (hi << 4) | lo;
  57.         }
  58.         return 0;
  59. }
  60. EXPORT_SYMBOL(hex2bin);
  61.  
  62. /**
  63.  * bin2hex - convert binary data to an ascii hexadecimal string
  64.  * @dst: ascii hexadecimal result
  65.  * @src: binary data
  66.  * @count: binary data length
  67.  */
  68. char *bin2hex(char *dst, const void *src, size_t count)
  69. {
  70.         const unsigned char *_src = src;
  71.  
  72.         while (count--)
  73.                 dst = hex_byte_pack(dst, *_src++);
  74.         return dst;
  75. }
  76. EXPORT_SYMBOL(bin2hex);
  77.  
  78. /**
  79.  * hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory
  80.  * @buf: data blob to dump
  81.  * @len: number of bytes in the @buf
  82.  * @rowsize: number of bytes to print per line; must be 16 or 32
  83.  * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
  84.  * @linebuf: where to put the converted data
  85.  * @linebuflen: total size of @linebuf, including space for terminating NUL
  86.  * @ascii: include ASCII after the hex output
  87.  *
  88.  * hex_dump_to_buffer() works on one "line" of output at a time, i.e.,
  89.  * 16 or 32 bytes of input data converted to hex + ASCII output.
  90.  *
  91.  * Given a buffer of u8 data, hex_dump_to_buffer() converts the input data
  92.  * to a hex + ASCII dump at the supplied memory location.
  93.  * The converted output is always NUL-terminated.
  94.  *
  95.  * E.g.:
  96.  *   hex_dump_to_buffer(frame->data, frame->len, 16, 1,
  97.  *                      linebuf, sizeof(linebuf), true);
  98.  *
  99.  * example output buffer:
  100.  * 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f  @ABCDEFGHIJKLMNO
  101.  *
  102.  * Return:
  103.  * The amount of bytes placed in the buffer without terminating NUL. If the
  104.  * output was truncated, then the return value is the number of bytes
  105.  * (excluding the terminating NUL) which would have been written to the final
  106.  * string if enough space had been available.
  107.  */
  108. int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize,
  109.                        char *linebuf, size_t linebuflen, bool ascii)
  110. {
  111.         const u8 *ptr = buf;
  112.         int ngroups;
  113.         u8 ch;
  114.         int j, lx = 0;
  115.         int ascii_column;
  116.         int ret;
  117.  
  118.         if (rowsize != 16 && rowsize != 32)
  119.                 rowsize = 16;
  120.  
  121.         if (len > rowsize)              /* limit to one line at a time */
  122.                 len = rowsize;
  123.         if (!is_power_of_2(groupsize) || groupsize > 8)
  124.                 groupsize = 1;
  125.         if ((len % groupsize) != 0)     /* no mixed size output */
  126.                 groupsize = 1;
  127.  
  128.         ngroups = len / groupsize;
  129.         ascii_column = rowsize * 2 + rowsize / groupsize + 1;
  130.  
  131.         if (!linebuflen)
  132.                 goto overflow1;
  133.  
  134.         if (!len)
  135.                 goto nil;
  136.  
  137.         if (groupsize == 8) {
  138.                 const u64 *ptr8 = buf;
  139.  
  140.                 for (j = 0; j < ngroups; j++) {
  141.                         ret = snprintf(linebuf + lx, linebuflen - lx,
  142.                                        "%s%16.16llx", j ? " " : "",
  143.                                        get_unaligned(ptr8 + j));
  144.                         if (ret >= linebuflen - lx)
  145.                                 goto overflow1;
  146.                         lx += ret;
  147.                 }
  148.         } else if (groupsize == 4) {
  149.                 const u32 *ptr4 = buf;
  150.  
  151.                 for (j = 0; j < ngroups; j++) {
  152.                         ret = snprintf(linebuf + lx, linebuflen - lx,
  153.                                        "%s%8.8x", j ? " " : "",
  154.                                        get_unaligned(ptr4 + j));
  155.                         if (ret >= linebuflen - lx)
  156.                                 goto overflow1;
  157.                         lx += ret;
  158.                 }
  159.         } else if (groupsize == 2) {
  160.                 const u16 *ptr2 = buf;
  161.  
  162.                 for (j = 0; j < ngroups; j++) {
  163.                         ret = snprintf(linebuf + lx, linebuflen - lx,
  164.                                        "%s%4.4x", j ? " " : "",
  165.                                        get_unaligned(ptr2 + j));
  166.                         if (ret >= linebuflen - lx)
  167.                                 goto overflow1;
  168.                         lx += ret;
  169.                 }
  170.         } else {
  171.                 for (j = 0; j < len; j++) {
  172.                         if (linebuflen < lx + 2)
  173.                                 goto overflow2;
  174.                         ch = ptr[j];
  175.                         linebuf[lx++] = hex_asc_hi(ch);
  176.                         if (linebuflen < lx + 2)
  177.                                 goto overflow2;
  178.                         linebuf[lx++] = hex_asc_lo(ch);
  179.                         if (linebuflen < lx + 2)
  180.                                 goto overflow2;
  181.                         linebuf[lx++] = ' ';
  182.                 }
  183.                 if (j)
  184.                         lx--;
  185.         }
  186.         if (!ascii)
  187.                 goto nil;
  188.  
  189.         while (lx < ascii_column) {
  190.                 if (linebuflen < lx + 2)
  191.                         goto overflow2;
  192.                 linebuf[lx++] = ' ';
  193.         }
  194.         for (j = 0; j < len; j++) {
  195.                 if (linebuflen < lx + 2)
  196.                         goto overflow2;
  197.                 ch = ptr[j];
  198.                 linebuf[lx++] = (isascii(ch) && isprint(ch)) ? ch : '.';
  199.         }
  200. nil:
  201.         linebuf[lx] = '\0';
  202.         return lx;
  203. overflow2:
  204.         linebuf[lx++] = '\0';
  205. overflow1:
  206.         return ascii ? ascii_column + len : (groupsize * 2 + 1) * ngroups - 1;
  207. }
  208. EXPORT_SYMBOL(hex_dump_to_buffer);
  209.  
  210. #ifdef CONFIG_PRINTK
  211. /**
  212.  * print_hex_dump - print a text hex dump to syslog for a binary blob of data
  213.  * @level: kernel log level (e.g. KERN_DEBUG)
  214.  * @prefix_str: string to prefix each line with;
  215.  *  caller supplies trailing spaces for alignment if desired
  216.  * @prefix_type: controls whether prefix of an offset, address, or none
  217.  *  is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
  218.  * @rowsize: number of bytes to print per line; must be 16 or 32
  219.  * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
  220.  * @buf: data blob to dump
  221.  * @len: number of bytes in the @buf
  222.  * @ascii: include ASCII after the hex output
  223.  *
  224.  * Given a buffer of u8 data, print_hex_dump() prints a hex + ASCII dump
  225.  * to the kernel log at the specified kernel log level, with an optional
  226.  * leading prefix.
  227.  *
  228.  * print_hex_dump() works on one "line" of output at a time, i.e.,
  229.  * 16 or 32 bytes of input data converted to hex + ASCII output.
  230.  * print_hex_dump() iterates over the entire input @buf, breaking it into
  231.  * "line size" chunks to format and print.
  232.  *
  233.  * E.g.:
  234.  *   print_hex_dump(KERN_DEBUG, "raw data: ", DUMP_PREFIX_ADDRESS,
  235.  *                  16, 1, frame->data, frame->len, true);
  236.  *
  237.  * Example output using %DUMP_PREFIX_OFFSET and 1-byte mode:
  238.  * 0009ab42: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f  @ABCDEFGHIJKLMNO
  239.  * Example output using %DUMP_PREFIX_ADDRESS and 4-byte mode:
  240.  * ffffffff88089af0: 73727170 77767574 7b7a7978 7f7e7d7c  pqrstuvwxyz{|}~.
  241.  */
  242. void print_hex_dump(const char *level, const char *prefix_str, int prefix_type,
  243.                     int rowsize, int groupsize,
  244.                     const void *buf, size_t len, bool ascii)
  245. {
  246.         const u8 *ptr = buf;
  247.         int i, linelen, remaining = len;
  248.         unsigned char linebuf[32 * 3 + 2 + 32 + 1];
  249.  
  250.         if (rowsize != 16 && rowsize != 32)
  251.                 rowsize = 16;
  252.  
  253.         for (i = 0; i < len; i += rowsize) {
  254.                 linelen = min(remaining, rowsize);
  255.                 remaining -= rowsize;
  256.  
  257.                 hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
  258.                                    linebuf, sizeof(linebuf), ascii);
  259.  
  260.                 switch (prefix_type) {
  261.                 case DUMP_PREFIX_ADDRESS:
  262.                         printk("%s%s%p: %s\n",
  263.                                level, prefix_str, ptr + i, linebuf);
  264.                         break;
  265.                 case DUMP_PREFIX_OFFSET:
  266.                         printk("%s%s%.8x: %s\n", level, prefix_str, i, linebuf);
  267.                         break;
  268.                 default:
  269.                         printk("%s%s%s\n", level, prefix_str, linebuf);
  270.                         break;
  271.                 }
  272.         }
  273. }
  274. EXPORT_SYMBOL(print_hex_dump);
  275.  
  276. #if !defined(CONFIG_DYNAMIC_DEBUG)
  277. /**
  278.  * print_hex_dump_bytes - shorthand form of print_hex_dump() with default params
  279.  * @prefix_str: string to prefix each line with;
  280.  *  caller supplies trailing spaces for alignment if desired
  281.  * @prefix_type: controls whether prefix of an offset, address, or none
  282.  *  is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
  283.  * @buf: data blob to dump
  284.  * @len: number of bytes in the @buf
  285.  *
  286.  * Calls print_hex_dump(), with log level of KERN_DEBUG,
  287.  * rowsize of 16, groupsize of 1, and ASCII output included.
  288.  */
  289. void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
  290.                           const void *buf, size_t len)
  291. {
  292.         print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, 16, 1,
  293.                        buf, len, true);
  294. }
  295. EXPORT_SYMBOL(print_hex_dump_bytes);
  296. #endif /* !defined(CONFIG_DYNAMIC_DEBUG) */
  297. #endif /* defined(CONFIG_PRINTK) */
  298.