Discussion :

[kahrah]

Bonjour,
Enfaîte, je voulais retourner un message qui contient tout ces champs là :
sizeof(unsigned int) + sizeof(char) + sizeof(uid_t) + sizeof(gid_t) + strlen(imprimante) + strlen(reference) + 2

du coup j'ai commencé à programmer un truc mais ça marche pas et aussi je sais pas comment faire pour ajouter à ce message le getuid() et le getgid():

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
 
 
 
char *message(char *imprimante, char *reference){
  char *message1;
  message1= malloc(sizeof(unsigned int) + sizeof(char) +sizeof(uid_t) +
                         + sizeof(gid_t) + strlen(imprimante) + strlen(reference)
                         + 2);
  memcpy(message1,imprimante,strlen(imprimante)+ 1);
  memcpy(message1,reference,strlen(reference)+ 1);
 
  return (message1);
 
}
 
int main(){
  char *message1;
  char *message2;
  message1 = "loulou";
  message2 = "lala";
  printf("le message est : %s\n",message(message1, message2));
 
  return 0;
}

Merci pour votre aide.

[Bktero]

Tu devrais regarder du côté de sprintf().

Voir
http://c.developpez.com/faq/?page=st...RINGS_strtonum
http://c.developpez.com/faq/?page=st...STRINGS_strcat

[Sve@r]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
  memcpy(message1,imprimante,strlen(imprimante)+ 1);
  memcpy(message1,reference,strlen(reference)+ 1);
 
  return (message1);
 
}
 
int main(){
  char *message1;
  char *message2;
  message1 = "loulou";
  message2 = "lala";
  printf("le message est : %s\n",message(message1, message2));
 
  return 0;
}

Salut
memcpy() n'est pas fait pour copier des chaines mais des zones mémoires. Donc la zone copiée n'est absolument pas assurée de contenir le '\0' final nécessaire à toute chaine
2 solutions

1. tu rajoutes toi-même le '\0' avant de renvoyer la chaine
2. tu utilises strcpy() au lieu de memcpy()

Ensuite, comme l'a dit Bktero, quand tu veux créer une chaine plus complexe, vaut mieux utiliser sprintf() plus pratique que de le faire à la main (possible mais fastidieux)

[Médinoc]

@Sve@r: memcpy(dest, src, strlen(src)+1) copie le caractère nul terminal.

@kahrah: Si tu veux les stocker directement sous forme de nombre (plutôt qu'en tant que chaîne de caractères) le seul problème pour ça sera de respecter l'endianness à utiliser (l'ordre des octets du nombre).

Traditionnellement pour des données transmises sur un réseau, il est recommandé d'utilisé l'ordre big-endian (on commence par le poids fort) quelle que soit l'endianness de la machine. Ainsi, on aurait:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <limits.h>
 
//Écrit un nombre en big-endian, octet par octet
writeNumber(void* buffer, unsigned long long number, size_t numberSize)
{
	//Index commençant à 1 (on va de numberSize à 1 inclus)
	unsigned char * byteBuffer = buffer;
	size_t byte1basedIndex = numberSize;
	for( byte1basedIndex = numberSize ; byte1basedIndex>0 ; byte1basedIndex--)
	{
		//Index commençant à zéro (va de numberSize-1 à zéro inclus)
		size_t byte0basedIndex = byte1basedIndex - 1;
		//On prend l'octet correspondant
		unsigned char theByte = (unsigned char)(number >> (byte0basedIndex*CHAR_BIT));
 
		//On l'écrit dans le buffer
		*byteBuffer = theByte;
		byteBuffer++;
	}
}
 
char *creerMessage(int a, char b, char const*imprimante, char const*reference) {
	char *message1;
	message1= malloc(sizeof(unsigned int) + sizeof(char)
	 + sizeof(uid_t) + sizeof(gid_t)
	 + strlen(imprimante) + strlen(reference) + 2);
	if(message1 != NULL) {
		char* ecriture = message1;
		//On écrit en avançant le pointeur à chaque fois
		writeNumber(ecriture, a, sizeof(int));
		ecriture += sizeof(int);
		writeNumber(ecriture, b, sizeof(char));
		ecriture += sizeof(char);
		writeNumber(ecriture, getuid(), sizeof(uid_t));
		ecriture += sizeof(uid_t);
		writeNumber(ecriture, getgid(), sizeof(gid_t));
		ecriture += sizeof(gid_t);
		memcpy(ecriture, imprimante, strlen(imprimante)+1);
		ecriture += strlen(imprimante)+1;
		memcpy(ecriture, reference, strlen(reference)+1);
		ecriture += strlen(reference)+1;
	}
 
	return (message1);
}
 
int main(void){
	char const *message1;
	char const *message2;
	char * message3;
	message1 = "loulou";
	message2 = "lala";
	message3 = creerMessage(42, 1, message1, message2);
	//On ne peut pas afficher le message obtenu avec printf() vu qu'il contient des données binaires
	free(message3);
	return 0;
}

Par contre, c'est assez dûr de retrouver la taille. Sauf si le fameux int au début est censé être ça.

[Sve@r]

@Sve@r: memcpy(dest, src, strlen(src)+1) copie le caractère nul terminal.

Exact, j'avais pas lu l'instruction en détail. Ceci dit, pourquoi faire simple...

Traditionnellement pour des données transmises sur un réseau, il est recommandé d'utilisé l'ordre big-endian

Ca je savais pas. Je sais utiliser les primitives htons() et htonl() et leurs inverses ntohs() et ntohl() mais le fait qu'un "net short" ou "net long" soit big-endian ou little-endian restait pour moi un détail mineur (voire inutile)

[Médinoc]

Ceci dit, pourquoi faire simple...

Dans le cas actuel, je pense que c'est stupide. Par contre, si tu avais eu:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
size_t cchSize = strlen(src)+1;
size_t cbSize = cchSize * sizeof *src;
char* dest = malloc(cbSize);
memcpy(dest, src, cbSize);

Ce serait sans doute plus rapide avec memcpy() (qui peut copier par mots entiers) qu'avec strcpy() (qui doit vérifier chaque octet).
Mais bien sûr, c'est de l'optimisation prématurée.