Objetivo: imprimir un número variable de bytes utilizando un especificador de formato único.
Entorno: x86-64 Ubuntu 20.04.3 LTS ejecutándose en VM en una máquina host x86-64.
Ejemplo:
Deje que %kmagic sea el especificador de formato que estoy buscando que imprima k bytes sacándolos de la pila y agregándolos a la salida. Luego, para que %rsp apunte a una región en la memoria que contiene los bytes 0xde 0xad 0xbe 0xef , quiero que printf("Next 4 bytes on the stack: %4magic") imprima Next 4 bytes on the stack: deadbeef .
Lo que probé hasta ahora:
%khhx , que desafortunadamente solo da como resultado k-1 espacios en blanco seguidos de dos caracteres hexadecimales (un byte de datos).%kx , que esperaba imprimir k/2 bytes interpretados como un número. Esto solo imprime 8 caracteres hexadecimales (4 bytes) precedidos por k - 8 espacios en blanco. El número de caracteres que no están en blanco impresos coincide con la longitud de los especificadores de formato, es decir, la longitud esperada de %hhx es 2, que también es el número de caracteres que no están en blanco impresos. Lo mismo vale para %x , que se espera que imprima 8 caracteres.
Pregunta: ¿Es posible obtener el comportamiento deseado? ¿Si es así, cómo?
¿Es posible obtener el comportamiento deseado? ¿Si es así, cómo?
No existe un especificador de formato printf para hacer lo que quieras.
es posible
Escriba su propia implementación printf que admita lo que desea. Utilice herramientas específicas de la implementación para crear su propio especificador de formato printf . Puede inspirarse en el especificador de formato printk %*phN del kernel de Linux .
No es posible usar printf estándar. Debe escribir su propia función y personalizar la función printf .
http://www.gnu.org/software/libc/manual/html_node/Customizing-Printf.html
Ejemplo (volcado simple):
int printdump (FILE *stream, const struct printf_info *info, const void *const *args) { const unsigned char *ptr = *(const unsigned char **)args[0]; size_t size = *(size_t*)args[1]; for(size_t i = 1; i <= size; i++) { fprintf(stream, "%02X%c", ptr[i-1], i % 8 ? ' ' : '\n'); } return 1; } int printdumpargs (const struct printf_info *info, size_t n, int *argtypes) { if (n == 2) argtypes[0] = PA_POINTER; argtypes[1] = PA_INT; return 2; } int main(void) { double x[4] = {456543645.6786e45, 456543654, 1e345, -345.56e67}; register_printf_function ('Y', printdump, printdumpargs); printf("%Y\n", &x, sizeof(x)); }Por lo que veo está depreciado ahora (probablemente nadie lo estaba usando)
https://godbolt.org/z/qKs6e1d9q
Producción:
30 18 CB 5A EF 10 13 4B 00 00 00 A6 4D 36 BB 41 00 00 00 00 00 00 F0 7F C4 5D ED 48 9C 05 60 CENo existe un especificador de conversión estándar para su propósito, pero puede lograr su objetivo en C99 utilizando una función auxiliar y una matriz dinámica:
#include <stdio.h> char *dump_bytes(char *buf, const void *p, size_t count) { const unsigned char *src = p; char *dest = buf; while (count --> 0) { dest += sprintf(dest, "%.2X", *src++); if (count) *dest++ = ' '; } *dest = '\0'; // return an empty sting for an empty memory chunk return buf; } int main() { long n = 0x12345; printf("n is at address %p with contents: %s\n", (void *)&n, dump_bytes((char[3 * sizeof(n)]){""}, &n, sizeof(n))); return 0; } Salida: n is at address 0x7fff523f57d8 with contents: 45 23 01 00 00 00 00 00
Puede usar una macro para una invocación más simple:
#define DUMPBYTES(p, n) dump_bytes((char[3 * (n)]){""}, p, n) int main() { char *p = malloc(5); printf("allocated 5 bytes at address %p with contents: %s\n", p, DUMPBYTES(p, 5)); free(p); return 0; }