Bonjour,

Je dois pouvoir effectuer une communication entre 2 processus en langage C avec des socket sous UNIX.

J'ai commencé à coder le serveur et le client. Lorsque je démarre le serveur, ensuite le client, tout se passe bien. Le serveur passe dans la fonction accept() qui bloque tant que le serveur n'a pas reçu de demande de connexion d'un client. Le client arrive bien à se connecter. tout se passe bien de lors de la connexion (du moins, je pense).

Le problème est que je n'arrive pas a envoyer une chaîne de caractère entre le client et le serveur. Vu que l'appel de la fonction read() dans le code du serveur lit quelques chose (car read() est un appel bloquant), je me dis qu'il reçoit quelques chose. Mais lors de l'affichage, la chaîne de caractère reçu est vide. Ce que je ne comprends pas

Voici, ci-dessous le code du serveur et du client

Code du serveur :

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

main(){
  struct sockaddr_in bd, s;
  int sock, h, len;
  char buf[255] = "";
  sock = socket(PF_INET, SOCK_STREAM, 0);
  if(sock==-1) { perror("SOCKET"); exit(1); }
  bd.sin_family = AF_INET;
  bd.sin_port = htons(5990);
  if(!inet_aton("127.0.0.1", (struct in_addr *)&bd.sin_addr.s_addr)) { perror("INET_ATON"); exit(1); }
  if(bind(sock, (struct sockaddr *)&bd, sizeof(bd))==-1) { perror("BIND"); exit(1); }
  listen(sock, 1);
  h = accept(sock, (struct sockaddr *)&s, &len);
  read(h, buf, 255);
  printf("message reçu : %s\n", buf);
  printf("Longueur du message : %d\n", strlen(buf));
  close(sock);
}

Code du client :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>

main(){
  int sd, res;
  struct sockaddr_in sockstr;
  struct in_addr adresse;
  sd = socket(PF_INET, SOCK_STREAM, 0);
  if(sd==-1){ perror("SOCKET"); exit(1); }
  sockstr.sin_family = AF_INET;
  sockstr.sin_port = htons(5990);
  if(!inet_aton("127.0.0.1", &adresse)) { perror("INET_ATON"); exit(1); }
  sockstr.sin_addr = adresse;
  if(connect(sd, (struct sockaddr *)&sockstr, sizeof(sockstr))==-1) { perror("CONNECT"); exit(1); }
  write(sd, "Hello world !", 14);
  close(sd);
}

Je me doute qu'il doit y avoir une erreur dans mon code, mais je ne vois pas laquelle :/

Si quelqu'un pourrait jeter un coup d'oeil, ce serai génial.

Merci d'avance

Bizarre chez moi cela marche.

Il te manquer tout de même un include ( #include <unistd.h>) dans le code du serveur mais cela marche sans.

Je viens d'ajouter #include <unistd.h> dans le code du serveur mais ça ne change rien :/

D’où peux bien venir le problème ?

Je ne sais pas trop chez moi j'ai pas le problème cela marche.

Le problème vient peut être d'autre part.

Ça fonctionne chez moi aussi. Quelle est ta version de gcc ? As-tu essayé de compiler avec -Wall ?

J'ai essayé sur Ubuntu, ça fonctionne.

A la base, j'utilisais Mandriva qui est l'OS que j'utilise à mon école.

En tout cas, merci pour votre aide et votre disponibilité

C'est probablement la version de gcc qui diffère.

Je croyais que Mandriva était dead ?

Edit, après vérification, ça fait 3 ans que Mandriva n'est plus maintenu. Il faudrait peut être que ton école se renouvelle.

-
Edité par PyTony 20 août 2015 à 12:24:27

Je reprends un peu ce sujet, parce que j'ai tenté de faire un serveur multi-client avec une simple boucle avec un accept() dedans.

C'est-à-dire que le serveur reçoit une chaîne de caractère vide. Maintenant que j'ai une version récente de gcc, je pense que l'erreur doit venir de mon code mais je ne vois pas où.

Une idée ?

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
 
main(){
  struct sockaddr_in bd, s;
  int sock, h, len;
  char buf[255] = "";
  sock = socket(PF_INET, SOCK_STREAM, 0);
  if(sock==-1) { perror("SOCKET"); exit(1); }
  bd.sin_family = AF_INET;
  bd.sin_port = htons(5990);
  if(!inet_aton("127.0.0.1", (struct in_addr *)&bd.sin_addr.s_addr)) { perror("INET_ATON"); exit(1); }
  if(bind(sock, (struct sockaddr *)&bd, sizeof(bd))==-1) { perror("BIND"); exit(1); }
  listen(sock, 1);

  while(1){
    h = accept(sock, (struct sockaddr *)&s, &len);
    if(fork()==0){
      read(h, buf, 255);
      printf("message reçu : %s\n", buf);
      printf("Longueur du message : %d\n", strlen(buf));
      exit(0);
    }
  }

  close(sock);
}

Je ne comprends pas ce que tu veux dire, je suis un peu dépassé.

Je cherche simplement a faire communiquer des processus avec des sockets sous unix.

J'ai cherché sur le net pour essayé de répondre à mes interrogations, mais pas de réponses très concluante.

Je ne vois pas où la chaîne de caractère "Hello world !" est envoyé, je ne comprends pas du fait que, le client est bien connecté au serveur, et qu'il est censé recevoir cette chaîne.

Bien que ce soit possible sous unix, il est déconseillé d'utiliser write pour envoyer un message sur le réseau, je te conseille fortement d'utiliser send. Idem pour read, utilise recv. Pour le client, il est de bon usage d'utiliser getaddrinfo aussi.

Mis à part ça et que le code n'est pas bien indenté (un peu compact à mon avis) je ne vois pas d'erreur.

Shifty93 a écrit:

Je ne comprends pas ce que tu veux dire, je suis un peu dépassé.

Je cherche simplement a faire communiquer des processus avec des sockets sous unix.

J'ai cherché sur le net pour essayé de répondre à mes interrogations, mais pas de réponses très concluante.

Je ne vois pas où la chaîne de caractère "Hello world !" est envoyé, je ne comprends pas du fait que, le client est bien connecté au serveur, et qu'il est censé recevoir cette chaîne.

wireshark permet de regarder ce qui transite sur le réseau.

De ce faite tu peux regarder ce que tu envois et ce qui tu reçois. Cela permettra peut être de comprendre pourquoi ton programme ne marche pas.