copie d'une partie de la valeur d'un pointeur

Bonjour,
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 void dump(const uint8_t *buf, size_t buflen, bool bare) { int i=0; char * bu = (char *) malloc(100); bu =buf+5; if (bare) { while(buflen--) printf("%02X%s", *buf++, (buflen > 0) ? " " : ""); do { printf("%c",*bu); } while(*bu++); } }
Je souhaite copier une partie de la valeur de buf dans bu (à partir de la 6émé case du buf)

début : buf = buf +5 fin : buflen =buflen -7

J'ai fait bu =buf+5; mais ca marche pas, y a t-il quelqu'un qui a une idée comment ca marche et comment faire pour la limitation à la fin (buflen =buflen -7)

buflen est le nombre d'instruction.

Merci pour votre aide.

Il semble que memcpy réponde au besoin, ex:

Code:

memcpy(bu, &buf[5], buflen-7)

salut,

*(buf+5) doit fonctionner, par contre ça ne sert à rien d'allouer de la mémoire avec malloc si c'est pour perdre le pointeur sur la zone allouée à la ligne suivante, l'un dans l'autre y'a pas besoin d'allouer de mémoire ici

je te propose un truc dans ce style, surement très perfectible :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#define NUM 32
 
void dump (const char *buf, unsigned int buflen, unsigned int offset) {
   int line = 0, column = 0, nblines = buflen / NUM;
   unsigned char c;
 
   for (line = 0; line <= buflen / NUM; line++) {
      printf ("%08x  ", offset + line * NUM);
      for (column = 0; column < NUM; column++) {
         if ((line < nblines) || ((line == nblines) && (column <= buflen % NUM))) {
            c = *(buf + line * NUM + column);
            printf ("%02x%s", c, column == NUM - 1 ? "" : " ");
         } else {
            printf ("  %s", column == NUM - 1 ? "" : " ");
         }
     }
     printf ("  |");
     for (column = 0; column < NUM; column++) {
         if ((line < nblines) || ((line == nblines) && (column <= buflen % NUM))) {
            c = *(buf + line * NUM + column);
            printf ("%c", (c > 31 && c < 128) ? c : '.' );
         }
      }
      printf ("|\n");
   }
}
 
int main (void) {
   dump("une petite fonction qui permet de dumper n'importe quoi y compris du binaire \xde\xad\xbe\xef et réaliser un affichage pas trop dégueu", 124, 0x12340000);
   return 0;
}

Code:

1
2
3
4
12340000  75 6e 65 20 70 65 74 69 74 65 20 66 6f 6e 63 74 69 6f 6e 20 71 75 69 20 70 65 72 6d 65 74 20 64  |une petite fonction qui permet d|
12340020  65 20 64 75 6d 70 65 72 20 6e 27 69 6d 70 6f 72 74 65 20 71 75 6f 69 20 79 20 63 6f 6d 70 72 69  |e dumper n'importe quoi y compri|
12340040  73 20 64 75 20 62 69 6e 61 69 72 65 20 de ad be ef 20 65 74 20 72 c3 a9 61 6c 69 73 65 72 20 75  |s du binaire .... et r..aliser u|
12340060  6e 20 61 66 66 69 63 68 61 67 65 20 70 61 73 20 74 72 6f 70 20 64 c3 a9 67 75 65 75 00           |n affichage pas trop d..gueu.|

merci pour vos réponses,

memcpy, ca marche pas .

pour la deuxième réponse, j'ai pas bien saisi le paramètre d'entrée "offset" ni la valeur à donner pour NUM, merci de clarifier ça.

Citation:

Envoyé par souhailsou

memcpy, ca marche pas .

oui bien sûr que ça "marche", ça a fait ses preuves depuis le temps

Citation:

j'ai pas bien saisi le paramètre d'entrée "offset" ni la valeur à donner pour NUM

là encore n'hésite pas à faire quelque effort pour trouver par toi même surtout

il suffit de regarder l'output proposé dans mon précédent message, l'offset passé en paramètre est 0x12340000 (pris au pif pour l'exemple) et dans l'output les adresses affichées commencent à 12340000, puis 12340020, 12340040 etc.

quant à NUM c'est pareil, il suffisait de compiler et essayer de jouer avec la valeur pour se rendre compte que c'est simplement le nombre de valeurs qu'on veut afficher par ligne, la commande hexdump -C en affiche 16 par exemple par défaut, ici j'ai pris 32, c'est modifiable facilement.

Citation:

Envoyé par souhailsou

memcpy, ca marche pas

Si si, elle fonctionne très bien, mais soit tu ne l'as pas utilisée correctement, soit elle ne correspond pas à ce que tu veux faire. Explique-nous comment tu t'en es servi, pourquoi elle ne fonctionne pas chez toi, et nous pourrons t'aider avec l'emploi de cette fonction.

1)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void coap_dump(const uint8_t *buf, size_t buflen, bool bare) { int i=0; char * bu = (char *) malloc(100); if (bare) { while(buflen--) printf("%02X%s", *buf++, (buflen > 0) ? " " : ""); memcpy(bu,&buf[5],buflen-7); printf("%02X",bu); }}
Voila la tentative avec memcpy, elle termine avec une segmentation fault soit avec malloc ou pas

2) Pour la deuxième solution, j'ai intégré le code au sein de la fonction mais ça affiche une série octet alors que j'ai besoin de faire une juste copie de buf
Je suis pas trop familiarisé avec l'environnement, c'est pour cela que mes questions paraissent un peu fondamentales.

136c1100 ||
136c1110 ||
136c1120 ||
136c1130 ||
136c1140

Merci d'avance,

:tagcode:

Citation:

Je suis pas trop familiarisé avec l'environnement

c'est pas l'environnement c'est plutôt le langage à mon sens
Code:

1 2 3 memcpy(bu,&buf[5],buflen-7); /* ici la copie est effectuée, ça répond à l'intitulé du topic tel que tu le décris */ /* note que tu devrais avoir plus haut quelque chose du genre bu = malloc(buflen-7) et non pas malloc(100) */ printf("%02X",bu); /* <-- sauf que ça n'a pas de sens de faire ça */
qu'est-ce que tu cherches à faire avec bu exactement ?

g mis alloué 30 pour éviter tout genre de problème allocation et de même pour l'affichage
ca marche pas avec &buf[5], donc j'ai mis &buf+5
Code:

1 2 3 4 5 6 7 8 9 10 char *bu ; bu = malloc(30); if (bare) { while(buflen--) printf("%02X%s", *buf++, (buflen > 0) ? " " : ""); memcpy(bu,&buf+5,30); printf("%02X",bu);}}
et comme résultat j'ai obtenu

bu : 40 01 1C 3A B3 69 70 36 C1

buf : 02821EED0

Réellement je cherche à avoir le code ASCII de la chaine buf à partir de position 5 jusqu'a buflen -7, voila tout simplement.

Ben déjà, appeler une partie du buffer pointé "une partie de la valeur du pointeur", ça promet...

ca marche enfin avec le memcpy merci à tous