Bonjour je fai un petit programme incluant des sockets seulement ce ne veu pas compiler il me sort des erreurs comme koi mempcy et non déclarer strlen et non declarer, alors que les fichier include son bien present je ne comprend pas du tout, le programme compile bien sur un autre ordi sous linux et chez moi rien a faire. je suis sous mdk 9.2 merci de m'aider

affiche nous la trace que tu obtient ainsi que tes commande de compil plz

ben en faite c bon g reussi a configurer tous seul, merci kan meme

ne tennez pa compte du message que j'ai mis c'etai pour un autre poste desolé

voila les erreur qui s'affiche, merci de maider

socket.cpp: In function `int main()':
socket.cpp:53: error: `memcpy' undeclared (first use this function)
socket.cpp:53: error: (Each undeclared identifier is reported only once for each function it appears in.)
socket.cpp:66: error: invalid conversion from `const char*' to `int'
socket.cpp:71: error: invalid conversion from `int*' to `socklen_t*'
socket.cpp:82: error: `strlen' undeclared (first use this function)

Le problème du langage C est qu'il faut que le compilateur connaisse le type de chaque variable et chaque fonction qu'il aura à utiliser avant que tu les utilises.
Jusqu'à présent, si tu utilisais une fonction sans l'avoir déclarée, le compilo la mettait "int" par défaut mais ce comportement s'est durci et maintenant, il ne veut plus rien savoir.

En ligne 53, tu utilises "memcpy". Il faut donc que tu déclares cette fonction au début de ton source en y mettant la ligne
void *memcpy(void*, void*);

Fort heureusement, tu as à ta disposition des headers (fichiers ".h") qui contiennent toutes les déclarations des fonctions correspondantes.
Tu peux donc à la place mettre la ligne suivante:
#include <memory.h>

En ligne 66, je pense que tu essayes d'appeler une fonction qui utilise un entier et tu lui passes un pointeur sur un caractère (adresse). Bien qu'une adresse soit un nombre entier, le compilo n'aime pas du tout. Mais il me faudrait voir la ligne incriminée pour mieux te répondre

En ligne 71, c'est le même truc. Tu as un pointeur sur un entier et tu l'utilises comme pointeur sur "socklen_t" Mais j'aimerais mieux voir la ligne pour être certain de ma réponse

Ligne 82 pareil que ligne 53. Soit tu déclares la fonction "int strlen(char *); soit tu inclues le fichier "string.h" en mettant en début de ton source
#include <string.h>

voila le source

#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <netdb.h>
#include <memory.h>

#define TPTCP 13001

int main ()
{
char trame[128];
int sock, sock2, rts, lg_addr;
struct sockaddr_in sockname;
struct hostent *host;

host= gethostbyname("localhost");
if(host==(struct hostent *)NULL)
{
perror("Host inconnu\n");
exit(0);
}
else printf("Host connu! `\n");

sock=socket(AF_INET, SOCK_STREAM, 0);
if(sock== -1)
{
printf("Pas de socket");
exit(0);
}
else printf("Socket OK");

sockname.sin_family=(AF_INET);
sockname.sin_port=htonl(TPTCP);
memcpy(&sockname.sin_addr.s_addr,host->h_addr,host->h_length);

rts=bind(sock, (struct sockaddr *)&sockname, sizeof(sockname));

if(rts==-1)
{
printf("bind erreur");
}

rts=listen(sock, 5);
if(rts==-1)
{
perror("erreur listen");
close("sock");
exit(0);
}

lg_addr=host->h_length;
sock2=accept(sock,(struct sockaddr *)&sockname, &lg_addr);
if(sock2==-1);
{
perror("pb accept");
close(sock);
exit(0);
}

rts=recv(sock2, trame, 128, 0);
printf("Trame recue : %s\n",trame);
printf("Reponse: ");;gets(trame);
send(sock2, trame, strlen(trame)+1,0);
close(sock2);
close(sock);

}

Ok - Tout d'abord quelques petits trucs qui t'éviteront de gros ennuis

1) toujours mettre les "#include <sys/machin.h>" en premier car ce sont les plus important et il se peut que le "toto.h" qui a besoin du "sys/machin.h" ne l'inclue pas (tout le monde ne programme pas toujours comme il faudrait) donc de ton coté, pour pas avoir de soucis, tu mets tous les <sys/machin.h> en premier, surtout le "<sys/types.h>"

2) Afin d'être tranquille, je te conseille aussi de mettre avant le remplissage de sockname la ligne "memset(&sockname, 0, sizeof(struct sockaddr_in));" afin d'être certain que les zones non-initialisées soient à 0

3) ta ligne "bind" n'est pas bonne mais je comprends ton erreur. Dans le man, tu as lu que le prototype de "bind" acceptait en second argument un "struct sockaddr*" alors tu caste ton pointeur en "struct sockaddr*" ce qui est parfait dans 99% des cas, sauf ici.
En effet, les sockets acceptent des communications an AF_INET ou AF_UNIX. Ainsi, le man de "bind" explique la fonction de façon schématisée pour les deux domaines mais dans la réalité, le "bind" accepte directement des adresses sur un pointeur "sockaddr_in" dans le cas du "INET" et "sockaddr_un" dans le cas du "UNIX".
Voici la ligne que tu dois mettre:
rts=bind(sock, &sockname, sizeof(sockname));
ou bien
rts=bind(sock, &sockname, sizeof(struct sockaddr_in));

4) la ligne "accept" n'est pas bonne du tout. La structure "sockaddr_in" qu'elle reçoit en paramètre est destinée à stocker l'adresse du client qui se connecte à ton serveur. il te faut donc une deuxième variable que tu peux appeler "struct sockaddr_in adr_client" et tu appelle
accept(sock, &adr_client, &lg_addr);
Ici non-plus, pas besoin de caster ton pointeur (mais c'est très propre de le faire)

5) Tu lis une trame sur ta socket (moi j'utilise "read" mais "recv" marche aussi) mais es-tu certain que ta trame contienne bien le "0" final utilisé par "printf" et "strlen" ?

Je pense cependant que ton source est bon et que ton serveur doit marcher. Mais ce n'est pas la peine de mettre "5" dans le "listen", "1" doit suffire puisque tu n'attends apparemment qu'un seul client...

toujours un probleme sur la ligne accept(sock, &adr_client, &lg_addr);

socket.cpp:75: error: invalid conversion from `int*' to `socklen_t*'

j'ai beau mettre (struct sockaddrin *) pour le 2 parametre c pareil

Le "int*" c'est le 3° paramètre "&lg_addr"
Vérifie bien dans le "man accept" quel est le type de ce 3° paramètre !!!

Sous unix, il est "int*" alors tu définis une variable "lg" de type int et ça marche.

Apparemment, sous Linux, c'est une variable de type "socklen_t*"

Il est fortement probable que ce type "socklen_t" soit une redéfinition du type "int" mais essaye d'aller voir dans "sys/types.h" et/ou "sys/socket.h" pour en être certain.

De toute façon le compilo veut un ptr de type "socklen_t" alors tu te fais pas c..., tu définis une variable "socklen_t var" et tu appelles
accept(sock, &adr_client, &var);

Ensuite, ça devrait aller !

De toute façon, les deux derniers paramètres de "accept" sont destinés à recevoir
- l'adresse du client qui se connecte
- la longueur en octet de cette adresse
Si tu n'as pas besoin de ces infos, tu peux remplacer ces deux paramètres par "NULL"
accept(sock, NULL, NULL);

quand il se palit pour le sockaddr_in au lieu de sockaddr fait un cast vers un void * pour le faire taire.

A noter que sous linux l'ordre des include n'a pas d'importance, par contre sous BSD si.

Encore un petit truc:
Sur ton serveur, tu n'es pas obligé d'aller chercher l'adresse de "localhost" pour le stocker dans "sockname.sin_addr.s_addr", tu peux y mettre directement la constante INADDR_ANY